Entity framework 实体框架，基于条件构建查询

我想知道是否有人有更好的办法。atm返回

IQueryable

作为

ObjectQuery

在我看来是肮脏的

namespace Falcon.Business.Repositories
{
    using System;
    using System.Data.Objects;
    using System.Linq;
    using Falcon.Business.Criteria;
    using Falcon.Business.Entities;
    using Falcon.Business.Enums;
    using Falcon.Business.Extensions;
    using Falcon.Business.Repositories.Interfaces;
    using Falcon.Business.Services;
    using Falcon.Business.Services.Interfaces;
    using Falcon.Core.Extensions;

    public class MemberRepository : LinqRepository<Member>, IMemberRepository
    {
        public Member Fetch(MemberCriteria criteria)
        {
            ObjectQuery<Member> query = base.CreateQuery();

            query = this.AddRelations(query);
            query = this.AddCriteria(query, criteria);
            query = this.AddCriteriaOrder(query, criteria);

            return query.FirstOrDefault();
        }

        public IPagerService<Member> FetchAll(MemberCriteria criteria)
        {
            int page = (criteria.Page.HasValue) ? criteria.Page.Value : 1;
            int limit = criteria.Limit;
            int start = (page * limit) - limit;
            int total = this.Count(criteria);

            ObjectQuery<Member> query = base.CreateQuery();

            query = this.AddRelations(query);
            query = this.AddCriteria(query, criteria);
            query = this.AddCriteriaOrder(query, criteria);

            return new PagerService<Member>(query.Skip(start).Take(limit).ToList(), page, limit, total);
        }

        public int Count(MemberCriteria criteria)
        {
            ObjectQuery<Member> query = base.CreateQuery();

            query = this.AddCriteria(query, criteria);

            return query.Count();
        }

        public ObjectQuery<Member> AddCriteria(IQueryable<Member> query, MemberCriteria criteria)
        {
            if (criteria.Title.HasValue())
            {
                query = query.Where(q => q.Title == criteria.Title);
            }

            if (criteria.TitleUrl.HasValue())
            {
                query = query.Where(q => q.TitleUrl == criteria.TitleUrl);
            }

            if (criteria.EmailAddress.HasValue())
            {
                query = query.Where(q => q.EmailAddress == criteria.EmailAddress);
            }

            if (criteria.HostAddress.HasValue())
            {
                query = query.Where(q => q.HostAddress == criteria.HostAddress);
            }

            query = query.Where(q => q.Status == criteria.Status);

            return query as ObjectQuery<Member>;
        }

        public ObjectQuery<Member> AddCriteriaOrder(IQueryable<Member> query, MemberCriteria criteria)
        {
            if (criteria.Sort == SortMember.ID)
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.ID)
                    : query.OrderByDescending(q => q.ID);
            }
            else if (criteria.Sort == SortMember.Posts)
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.Posts)
                    : query.OrderByDescending(q => q.Posts);
            }
            else if (criteria.Sort == SortMember.Title)
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.Title)
                    : query.OrderByDescending(q => q.Title);
            }
            else if (criteria.Sort == SortMember.LastLogin)
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.LastLogin)
                    : query.OrderByDescending(q => q.LastLogin);
            }
            else if (criteria.Sort == SortMember.LastVisit)
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.LastVisit)
                    : query.OrderByDescending(q => q.LastVisit);
            }
            else
            {
                query = criteria.Order == SortOrder.Asc
                    ? query.OrderBy(q => q.Created)
                    : query.OrderByDescending(q => q.Created);
            }

            return query as ObjectQuery<Member>;
        }

        private ObjectQuery<Member> AddRelations(ObjectQuery<Member> query)
        {
            query = query.Include(x => x.Country);
            query = query.Include(x => x.TimeZone);
            query = query.Include(x => x.Profile);

            return query;
        }
    }
}

名称空间Falcon.Business.Repositories
{
使用制度；
使用System.Data.Object；
使用System.Linq；
使用Falcon.Business.Criteria；
使用Falcon.Business.Entities；
使用Falcon.Business.Enums；
使用Falcon.Business.Extensions；
使用Falcon.Business.Repositories.Interfaces；
使用Falcon.Business.Services；
使用Falcon.Business.Services.Interfaces；
使用Falcon.Core.Extensions；
公共类成员存储库：LinqRepository、IMemberRepository
{
公共成员获取（成员条件）
{
ObjectQuery=base.CreateQuery（）；
query=this.AddRelations（查询）；
query=this.AddCriteria（查询，条件）；
query=this.AddCriteriaOrder（查询，条件）；
返回query.FirstOrDefault（）；
}
公共IPagerService FetchAll（MemberCriteria标准）
{
int page=（criteria.page.HasValue）？criteria.page.Value:1；
int limit=标准。极限；
int start=（页面*限制）-限制；
int total=此.Count（标准）；
ObjectQuery=base.CreateQuery（）；
query=this.AddRelations（查询）；
query=this.AddCriteria（查询，条件）；
query=this.AddCriteriaOrder（查询，条件）；
返回新的PagerService（query.Skip（start）.Take（limit）.ToList（），page，limit，total）；
}
公共整数计数（成员标准）
{
ObjectQuery=base.CreateQuery（）；
query=this.AddCriteria（查询，条件）；
返回query.Count（）；
}
public ObjectQuery AddCriteria（IQueryable查询，MemberCriteria）
{
if（criteria.Title.HasValue（））
{
query=query.Where（q=>q.Title==criteria.Title）；
}
if（criteria.TitleUrl.HasValue（））
{
query=query.Where（q=>q.TitleUrl==criteria.TitleUrl）；
}
if（criteria.EmailAddress.HasValue（））
{
query=query.Where（q=>q.EmailAddress==criteria.EmailAddress）；
}
if（criteria.HostAddress.HasValue（））
{
query=query.Where（q=>q.HostAddress==criteria.HostAddress）；
}
query=query.Where（q=>q.Status==criteria.Status）；
将查询作为ObjectQuery返回；
}
public ObjectQuery AddCriteriaOrder（IQueryable查询，MemberCriteria条件）
{
if（criteria.Sort==SortMember.ID）
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.ID）
：query.OrderByDescending（q=>q.ID）；
}
else if（criteria.Sort==SortMember.Posts）
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.Posts）
：query.OrderByDescending（q=>q.Posts）；
}
else if（criteria.Sort==SortMember.Title）
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.Title）
：query.OrderByDescending（q=>q.Title）；
}
else if（criteria.Sort==SortMember.LastLogin）
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.LastLogin）
：query.OrderByDescending（q=>q.LastLogin）；
}
else if（criteria.Sort==SortMember.lastVisite）
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.lastVisite）
：query.OrderByDescending（q=>q.lastVisite）；
}
其他的
{
query=criteria.Order==SortOrder.Asc
？query.OrderBy（q=>q.Created）
：query.OrderByDescending（q=>q.Created）；
}
将查询作为ObjectQuery返回；
}
私有ObjectQuery添加关系（ObjectQuery查询）
{
query=query.Include（x=>x.Country）；
query=query.Include（x=>x.TimeZone）；
query=query.Include（x=>x.Profile）；
返回查询；
}
}
}

我也不喜欢返回objectquery，因为这样做会使您非常依赖实体框架。了解微软，他们可能会在版本2中做很多更改，所以你不想这样做

---

NHibernate使用标准，有点像您建议的，但它们的实现更通用。我喜欢比您更通用的实现示例，因为这样您就不需要为每个对象构建标准。另一方面，您的实现是类型化的，这也是非常整洁的。如果您想要两者兼而有之，一个更通用的类型化实现，那么您可能想看看NHibernate实现，但不要使用字符串，而是使用lambda函数和.Net泛型。我可以发布一个例子来说明如何做到这一点，但我目前没有在自己的机器上。

Heh，这应该是对T-SQL的改进！想想看：）只是开玩笑。@Rob Sanders+1：即使是开玩笑，你的观点也很有道理。目前，我仍然相信MVC的好处，但我想知道这种观点是否会得到重视。