Как я могу написать чистый репозиторий, не подвергая IQueryable остальной части моего приложения?

Ответ 1

Выявление IQueryable - очень жизнеспособное решение, и именно так большинство реализаций Репозитория делают это прямо сейчас. (Включая SharpArchitecture и FubuMVC contrib.)

Здесь вы ошибаетесь:

Однако, если вы не используете IQueryable, то методы, такие как GetAll() не очень практичны, так как ленивые оценка не будет происходить линия. Я не хочу возвращаться 10 000 записей используют только 10 из них позже.

Это неправда. Ваш пример верен, и вы должны переименовать GetAll() в более информативное имя.

Он не возвращает все элементы, если вы его вызываете. Для этого и предназначен IQueryable. Эта концепция называется "отложенная загрузка", поскольку она загружает только данные (и делает запросы к базе данных), когда вы перечисляете IQueryable.

Итак, скажем, у меня есть такой метод:

IQueryable<T> Retrieve() { ... }

Тогда я могу назвать это следующим образом:

Repository.Retrieve<Customer>().Single(c => c.ID == myID);

Это ТОЛЬКО извлекает одну строку из базы данных.

И это:

Repository.Retrieve<Customer>().Where(c => c.FirstName == "Joe").OrderBy(c => c.LastName);

Это также генерирует соответствующий запрос и выполняется только при его перечислении. (Он генерирует дерево выражений из запроса, а затем поставщик запроса должен перевести это в соответствующий запрос к источнику данных.)

Подробнее об этом можно прочитать в этой статье MSDN.

Ответ 2

Метод Rob действительно не решает вашу основную проблему и не хочет писать отдельные методы для каждого типа запросов, которые вы хотите запустить, и, к сожалению, если вы не используете IQueryable, то это то, что вы слева.

Уверены, что методы могут быть на уровне "службы", но это все равно означает писать "GetProductsByName, GetProductsByDate"...

Другим способом является:

GetProducts(QueryObject);

Это может дать вам некоторую выгоду от использования IQueryable, поскольку вы можете ограничить возвращаемое.

Ответ 3

hmm.. Я решил это разными способами в зависимости от типа используемого ORM.
Основная идея состоит в том, чтобы иметь один базовый класс репозитория и один метод запроса, который принимает так много параметров, указывающих все возможные варианты где /orderby/expand | include/paging/etc.

Вот быстрый и грязный пример с использованием LINQ to NHibernate (конечно, весь репозиторий должен быть подробным в реализации):

public class RepositoryBase
    {
        private ISession Session;

        public RepositoryBase()
        {
            Session = SessionPlaceHolder.Session;
        }



        public TEntity[] GetPaged<TEntity>(IEnumerable<Expression<Func<TEntity, bool>>> filters,
            IEnumerable<Expression<Func<TEntity, object>>> relatedObjects,
            IEnumerable<Expression<Func<TEntity, object>>> orderCriterias,
            IEnumerable<Expression<Func<TEntity, object>>> descOrderCriterias,
            int pageNumber, int pageSize, out int totalPages)
        {
            INHibernateQueryable<TEntity> nhQuery = Session.Linq<TEntity>();

            if (relatedObjects != null)
                foreach (var relatedObject in relatedObjects)
                {
                    if (relatedObject == null) continue;
                    nhQuery = nhQuery.Expand(relatedObject);
                }

            IQueryable<TEntity> query = nhQuery;

            if (filters != null)
                foreach (var filter in filters)
                {
                    if (filter == null) continue;
                    query = query.Where(filter);
                }

            bool pagingEnabled = pageSize > 0;

            if (pagingEnabled)
                totalPages = (int) Math.Ceiling((decimal) query.Count()/(decimal) pageSize);
            else
                totalPages = 1;

            if (orderCriterias != null)
                foreach (var orderCriteria in orderCriterias)
                {
                    if (orderCriteria == null) continue;
                    query = query.OrderBy(orderCriteria);
                }

            if (descOrderCriterias != null) 
                foreach (var descOrderCriteria in descOrderCriterias)
                {
                    if (descOrderCriteria == null) continue;
                    query = query.OrderByDescending(descOrderCriteria);
                }

            if (pagingEnabled)
                query = query.Skip(pageSize*(pageNumber - 1)).Take(pageSize);

            return query.ToArray();
        }
    }

Обычно вам нужно добавить много перегрузок цепочек как ярлыки, когда вам не нужен пейджинг, например, и т.д.

Вот еще один грязный. Извините, я не уверен, могу ли я представить последние. Это были черновики и в порядке, чтобы показать:

using Context = Project.Services.Repositories.EntityFrameworkContext;
using EntitiesContext = Project.Domain.DomainSpecificEntitiesContext;    
namespace Project.Services.Repositories
{
    public class EntityFrameworkRepository : IRepository
    {
        #region IRepository Members

        public bool TryFindOne<T>(Expression<Func<T, bool>> filter, out T result)
        {
            result = Find(filter, null).FirstOrDefault();

            return !Equals(result, default(T));
        }

        public T FindOne<T>(Expression<Func<T, bool>> filter)
        {
            T result;
            if (TryFindOne(filter, out result))
                return result;

            return default(T);
        }

        public IList<T> Find<T>() where T : class, IEntityWithKey
        {
            int count;
            return new List<T>(Find<T>(null, null, 0, 0, out count));
        }

        public IList<T> Find<T>(Expression<Func<T, bool>> filter, Expression<Func<T, object>> sort)
        {
            int count;
            return new List<T>(Find(filter, sort, 0, 0, out count));
        }

        public IEnumerable<T> Find<T>(Expression<Func<T, bool>> filter, Expression<Func<T, object>> sort, int pageSize,
                                      int pageNumber, out int count)
        {
            return ExecuteQuery(filter, sort, pageSize, pageNumber, out count) ?? new T[] {};
        }

        public bool Save<T>(T entity)
        {
            var contextSource = new EntityFrameworkContext();

            EntitiesContext context = contextSource.Context;

            EntityKey key = context.CreateEntityKey(GetEntitySetName(entity.GetType()), entity);

            object originalItem;
            if (context.TryGetObjectByKey(key, out originalItem))
            {
                context.ApplyPropertyChanges(key.EntitySetName, entity);
            }
            else
            {
                context.AddObject(GetEntitySetName(entity.GetType()), entity);
                //Attach(context, entity);
            }

            return context.SaveChanges() > 0;
        }

        public bool Delete<T>(Expression<Func<T, bool>> filter)
        {
            var contextSource = new EntityFrameworkContext();

            EntitiesContext context = contextSource.Context;

            int numberOfObjectsFound = 0;
            foreach (T entity in context.CreateQuery<T>(GetEntitySetName(typeof (T))).Where(filter))
            {
                context.DeleteObject(entity);
                ++numberOfObjectsFound;
            }

            return context.SaveChanges() >= numberOfObjectsFound;
        }

        #endregion

        protected IEnumerable<T> ExecuteQuery<T>(Expression<Func<T, bool>> filter, Expression<Func<T, object>> sort,
                                                 int pageSize, int pageNumber,
                                                 out int count)
        {
            IEnumerable<T> result;

            var contextSource = new EntityFrameworkContext();

            EntitiesContext context = contextSource.Context;

            ObjectQuery<T> originalQuery = CreateQuery<T>(context);
            IQueryable<T> query = originalQuery;

            if (filter != null)
                query = query.Where(filter);

            if (sort != null)
                query = query.OrderBy(sort);

            if (pageSize > 0)
            {
                int pageIndex = pageNumber > 0 ? pageNumber - 1 : 0;
                query = query.Skip(pageIndex).Take(pageSize);

                count = query.Count();
            }
            else 
                count = -1;


            result = ExecuteQuery(context, query);

            //if no paging total count is count of the entire result set
            if (count == -1) count = result.Count();

            return result;
        }

        protected internal event Action<ObjectContext, IEnumerable> EntitiesFound;

        protected void OnEntitiesFound<T>(ObjectContext context, params T[] entities)
        {
            if (EntitiesFound != null && entities != null && entities.Length > 0)
            {
                EntitiesFound(context, entities);
            }
        }

        //Allowing room for system-specific-requirement extensibility
        protected Action<IEnumerable> ItemsFound;

        protected IEnumerable<T> ExecuteQuery<T>(ObjectContext context, IQueryable<T> query)
        {
            IEnumerable<T> result = null;

            if (query is ObjectQuery)
            {
                var objectQuery = (ObjectQuery<T>) query;

                objectQuery.EnablePlanCaching = false;
                objectQuery.MergeOption = MergeOption.PreserveChanges;

                result = new List<T>(objectQuery);

                if (ItemsFound != null)
                    ItemsFound(result);

                return result;
            }

            return result;
        }

        internal static RelationshipManager GetRelationshipManager(object entity)
        {
            var entityWithRelationships = entity as IEntityWithRelationships;
            if (entityWithRelationships != null)
            {
                return entityWithRelationships.RelationshipManager;
            }

            return null;
        }


        protected ObjectQuery<T> CreateQuery<T>(ObjectContext context)
        {
            ObjectQuery<T> query = context.CreateQuery<T>(GetEntitySetName(typeof (T)));
            query = this.AggregateEntities(query);
            return query;
        }

        protected virtual ObjectQuery<T> AggregateEntities<T>(ObjectQuery<T> query)
        {
            return query;
        }

        private static string GetEntitySetName(Type entityType)
        {
            return string.Format("{0}Set", entityType.Name);
        }
    }

    public class EntityFrameworkContext
    {
        private const string CtxKey = "ctx";

        private bool contextInitialized
        {
            get { return HttpContext.Current.Items[CtxKey] != null;  }
        }

        public EntitiesContext Context
        {
            get
            {
                if (contextInitialized == false)
                {
                    HttpContext.Current.Items[CtxKey] = new EntitiesContext(ConfigurationManager.ConnectionStrings["CoonectionStringName"].ToString());
                }

                return (EntitiesContext)HttpContext.Current.Items[CtxKey];
            }
        }

        public void TrulyDispose()
        {
            if (contextInitialized)
            {
                Context.Dispose();
                HttpContext.Current.Items[CtxKey] = null;
            }
        }
    }

    internal static class EntityFrameworkExtensions
    {
        internal static ObjectQuery<T> Include<T>(this ObjectQuery<T> query,
                                                  Expression<Func<T, object>> propertyToInclude)
        {
            string include = string.Join(".", propertyToInclude.Body.ToString().Split('.').Skip(1).ToArray());

            const string collectionsLinqProxy = ".First()";
            include = include.Replace(collectionsLinqProxy, "");

            return query.Include(include);
        }

        internal static string After(this string original, string search)
        {
            if (string.IsNullOrEmpty(original))
                return string.Empty;

            int index = original.IndexOf(search);
            return original.Substring(index + search.Length);
        }
    }
}

В Коннерированной MVC Storefront он создал другой слой, называемый "Сервис", слой, который получил IQueryable результаты из репозитория и были ответственный за применение различных фильтры.

Во всех случаях никто не должен взаимодействовать с репозиторием напрямую, кроме уровня служб.

Наиболее гибкой задачей является позволить службам взаимодействовать с репозиторием так, как они хотят, так же, как и в предыдущем коде (но через одну единственную точку - например, также - написать DRY-код и найти место для оптимизации).
Однако более правильным способом с точки зрения общих шаблонов DDD является использование шаблона "Спецификация", в котором вы инкапсулируете все свои фильтры и т.д. В переменные (члены класса, в LINQ, как правило, типов делегатов). LINQ может извлечь большую выгоду из этого преимущества при объединении его с "Скомпилированными запросами". Если вы google {Specification Pattern} и {LINQ Compiled Queries}, вы приблизитесь к тому, что я имею в виду здесь.

Ответ 4

В результате я создал два набора методов, которые возвращают IEnumerable (в вашем случае IQueryable) и те, которые возвращают Collection (вытаскивают содержимое перед отправкой его из репозитория.)

Это позволяет мне создавать и создавать специальные запросы в службах за пределами репозитория, а также использовать методы репозитория, которые напрямую возвращают коллекцию, защищенную от побочных эффектов. Другими словами, объединение двух объектов репозитория вместе приводит к одному запросу выбора вместо одного запроса выбора для каждого найденного объекта.

Я полагаю, вы могли бы установить свой уровень защиты, чтобы по-настоящему плохо происходить.

Ответ 5

Попытавшись найти жизнеспособное решение этой проблемы самостоятельно, есть то, что кажется хорошим решением в Внедрение репозитория и шаблона работы в Приложение ASP.NET MVC (9 из 10).

public virtual IEnumerable<TEntity> Get(
    Expression<Func<TEntity, bool>> filter = null,
    Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
    string includeProperties = "") 
    {
        IQueryable<TEntity> query = dbSet;

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

В статье не говорится об этой точной проблеме, но рассказывается об общих, многоразовых методах репозитория.

Пока это все, что мне удалось найти в качестве решения.