Entity Framework, consulta de construcción basada en criterios

Question

Me preguntaba si alguien tenía una mejor idea de cómo hacer esto. atm regresando IQueryable<Member> como ObjectQuery<Member> me parece sucio.

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;
        }
    }
}

Answer 1

Tampoco me gusta devolver una consulta de objeto, porque hacerlo te hará muy dependiente de Entity Framwork. Conociendo a Microsoft, probablemente hagan muchos cambios en la versión 2, por lo que no desea hacer esto.

NHibernate utiliza criterios, un poco como sugirió, pero su implementación es mucho más genérica. Me gusta la implementación más genérica más de lo que muestra, porque no necesita crear criterios para cada objeto. Por otro lado, su implementación está escrita, lo que también es muy bueno. Si desea lo mejor de ambos, una implementación más genérica que se escribe, es posible que desee echar un vistazo a la implementación de NHibernate, pero en lugar de usar cadenas, use funciones lambda y genéricos .Net. Podría publicar un ejemplo de cómo hacerlo, pero actualmente no estoy en mi propia máquina.