/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <returns>The aggregate roots.</returns> public IQueryable <TAggregateRoot> FindAll <TKey, TAggregateRoot>( ISpecification <TAggregateRoot> specification, System.Linq.Expressions.Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) where TAggregateRoot : class, IAggregateRoot <TKey> { EnsureSession(); IQueryable <TAggregateRoot> result = null; var query = this.session.Query <TAggregateRoot>().Where(specification.GetExpression()); switch (sortOrder) { case Storage.SortOrder.Ascending: if (sortPredicate != null) { result = query.OrderBy(sortPredicate); } break; case Storage.SortOrder.Descending: if (sortPredicate != null) { result = query.OrderByDescending(sortPredicate); } break; default: result = query; break; } // Use of implicit transactions is discouraged. // For more information please refer to: http://www.hibernatingrhinos.com/products/nhprof/learn/alert/DoNotUseImplicitTransactions Commit(); return(result); }
public IQueryable <TAggregateRoot> GetAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { return(GetAll(new AnySpecification <TAggregateRoot>(), sortPredicate, sortOrder)); }
public PagedResult <TAggregateRoot> FindAll <TAggregateRoot>(Specifications.ISpecification <TAggregateRoot> specification, System.Linq.Expressions.Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) where TAggregateRoot : class, IAggregateRoot { EnsureSession(); if (pageNumber <= 0) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "The pageNumber is one-based and should be larger than zero."); } if (pageSize <= 0) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "The pageSize is one-based and should be larger than zero."); } if (sortPredicate == null) { throw new ArgumentNullException("sortPredicate"); } var query = this._session.Query <TAggregateRoot>() .Where(specification.Expression); int skip = (pageNumber - 1) * pageSize; int take = pageSize; int totalCount = 0; int totalPages = 0; List <TAggregateRoot> pagedData = null; PagedResult <TAggregateRoot> result = null; switch (sortOrder) { case Storage.SortOrder.Ascending: totalCount = query.ToFutureValue(x => x.Count()).Value; totalPages = (totalCount + pageSize - 1) / pageSize; pagedData = query.OrderBy(sortPredicate).Skip(skip).Take(take).ToFuture().ToList(); result = new PagedResult <TAggregateRoot>(totalCount, totalPages, pageSize, pageNumber, pagedData); break; case Storage.SortOrder.Descending: totalCount = query.ToFutureValue(x => x.Count()).Value; totalPages = (totalCount + pageSize - 1) / pageSize; pagedData = query.OrderByDescending(sortPredicate).Skip(skip).Take(take).ToFuture().ToList(); result = new PagedResult <TAggregateRoot>(totalCount, totalPages, pageSize, pageNumber, pagedData); break; default: break; } Commit(); return(result); }
/// <summary> /// Selects all the object from the current storage. /// </summary> /// <typeparam name="T">The type of the object.</typeparam> /// <param name="specification">The instance of <see cref="ISpecification{T}"/> /// which represents the filter criteria.</param> /// <param name="orders">The <see cref="PropertyBag"/> which represents the fields for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> value which represents the sort order.</param> /// <param name="connection">The instance of <see cref="System.Data.Common.DbConnection"/> which represents /// the connection to a database.</param> /// <param name="transaction">The instance of <see cref="System.Data.Common.DbTransaction"/> which represents /// the database transaction.</param> /// <returns>All the objects selected.</returns> protected virtual IEnumerable <T> DoSelect <T>(ISpecification <T> specification, PropertyBag orders, Storage.SortOrder sortOrder, DbConnection connection, DbTransaction transaction = null) where T : class, new() { if (connection == null) { throw new ArgumentNullException("connection"); } if (connection.State != ConnectionState.Open) { throw new ArgumentException("The database connection is not in an Open state.", "connection"); } WhereClauseBuildResult whereBuildResult = null; var sql = string.Format("SELECT {0} FROM {1}", GetFieldNameList <T>(), GetTableName <T>()); if (specification != null) { var expression = specification.GetExpression(); whereBuildResult = GetWhereClauseBuilder <T>().BuildWhereClause(expression); sql += " WHERE " + whereBuildResult.WhereClause; } if (orders != null && sortOrder != Storage.SortOrder.Unspecified) { sql += " ORDER BY " + GetOrderByFieldList <T>(orders); switch (sortOrder) { case Storage.SortOrder.Ascending: sql += " ASC"; break; case Storage.SortOrder.Descending: sql += " DESC"; break; default: break; } } using (var command = CreateCommand(sql, connection)) { if (transaction != null) { command.Transaction = transaction; } if (specification != null) { command.Parameters.Clear(); var parameters = GetSelectCriteriaDbParameterList <T>(whereBuildResult.ParameterValues); foreach (var parameter in parameters) { command.Parameters.Add(parameter); } } using (var reader = command.ExecuteReader()) { var ret = new List <T>(); while (reader.Read()) { ret.Add(CreateFromReader <T>(reader)); } return(ret); } } }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="pageNumber">The page number.</param> /// <param name="pageSize">The number of objects per page.</param> /// <param name="eagerLoadingProperties">The properties for the aggregated objects that need to be loaded.</param> /// <returns>The aggregate root.</returns> protected override PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { return(this.DoFindAll(specification, sortPredicate, sortOrder, pageNumber, pageSize)); }
/// <summary> /// Finds all the aggregate roots that match the given specification with paging enabled, and sorts the aggregate roots /// by using the provided sort predicate and the specified sort order. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="pageNumber">The number of objects per page.</param> /// <param name="pageSize">The number of objects per page.</param> /// <returns>All the aggregate roots that match the given specification and were sorted by using the given sort predicate and the sort order.</returns> protected override PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) { return(nhContext.FindAll <TKey, TAggregateRoot>(specification, sortPredicate, sortOrder, pageNumber, pageSize)); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="pageNumber">The page number.</param> /// <param name="pageSize">The number of objects per page.</param> /// <param name="eagerLoadingProperties">The properties for the aggregated objects that need to be loaded.</param> /// <returns>The aggregate root.</returns> protected override PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { if (pageNumber <= 0) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "The pageNumber is one-based and should be larger than zero."); } if (pageSize <= 0) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "The pageSize is one-based and should be larger than zero."); } if (sortPredicate == null) { throw new ArgumentNullException("sortPredicate"); } int skip = (pageNumber - 1) * pageSize; int take = pageSize; var dbset = efContext.Context.Set <TAggregateRoot>(); IQueryable <TAggregateRoot> queryable = null; if (eagerLoadingProperties != null && eagerLoadingProperties.Length > 0) { var eagerLoadingProperty = eagerLoadingProperties[0]; var eagerLoadingPath = this.GetEagerLoadingPath(eagerLoadingProperty); var dbquery = dbset.Include(eagerLoadingPath); for (int i = 1; i < eagerLoadingProperties.Length; i++) { eagerLoadingProperty = eagerLoadingProperties[i]; eagerLoadingPath = this.GetEagerLoadingPath(eagerLoadingProperty); dbquery = dbquery.Include(eagerLoadingPath); } queryable = dbquery.Where(specification.GetExpression()); } else { queryable = dbset.Where(specification.GetExpression()); } switch (sortOrder) { case SortOrder.Ascending: var pagedGroupAscending = queryable.SortBy(sortPredicate).Skip(skip).Take(take).GroupBy(p => new { Total = queryable.Count() }).FirstOrDefault(); if (pagedGroupAscending == null) { return(null); } return(new PagedResult <TAggregateRoot>(pagedGroupAscending.Key.Total, (pagedGroupAscending.Key.Total + pageSize - 1) / pageSize, pageSize, pageNumber, pagedGroupAscending.Select(p => p).ToList())); case SortOrder.Descending: var pagedGroupDescending = queryable.SortByDescending(sortPredicate).Skip(skip).Take(take).GroupBy(p => new { Total = queryable.Count() }).FirstOrDefault(); if (pagedGroupDescending == null) { return(null); } return(new PagedResult <TAggregateRoot>(pagedGroupDescending.Key.Total, (pagedGroupDescending.Key.Total + pageSize - 1) / pageSize, pageSize, pageNumber, pagedGroupDescending.Select(p => p).ToList())); default: break; } return(null); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="pageNumber">The number of objects per page.</param> /// <param name="pageSize">The number of objects per page.</param> /// <returns>The aggregate roots.</returns> protected override PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) { if (pageNumber <= 0) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "The pageNumber is one-based and should be larger than zero."); } if (pageSize <= 0) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "The pageSize is one-based and should be larger than zero."); } if (sortPredicate == null) { throw new ArgumentNullException("sortPredicate"); } var query = efContext.Context.Set <TAggregateRoot>() .Where(specification.GetExpression()); int skip = (pageNumber - 1) * pageSize; int take = pageSize; switch (sortOrder) { case SortOrder.Ascending: var pagedGroupAscending = query.SortBy(sortPredicate).Skip(skip).Take(take).GroupBy(p => new { Total = query.Count() }).FirstOrDefault(); if (pagedGroupAscending == null) { return(null); } return(new PagedResult <TAggregateRoot>(pagedGroupAscending.Key.Total, (pagedGroupAscending.Key.Total + pageSize - 1) / pageSize, pageSize, pageNumber, pagedGroupAscending.Select(p => p).ToList())); case SortOrder.Descending: var pagedGroupDescending = query.SortByDescending(sortPredicate).Skip(skip).Take(take).GroupBy(p => new { Total = query.Count() }).FirstOrDefault(); if (pagedGroupDescending == null) { return(null); } return(new PagedResult <TAggregateRoot>(pagedGroupDescending.Key.Total, (pagedGroupDescending.Key.Total + pageSize - 1) / pageSize, pageSize, pageNumber, pagedGroupDescending.Select(p => p).ToList())); default: break; } return(null); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页数</param> /// <returns>聚合根集合</returns> public PagedResult <TAggregateRoot> FindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) { return(this.DoFindAll(specification, sortPredicate, sortOrder, pageNumber, pageSize)); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <returns>聚合根集合</returns> public IQueryable <TAggregateRoot> FindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { return(this.DoFindAll(specification, sortPredicate, sortOrder)); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页数</param> /// <param name="eagerLoadingProperties">聚合根实例需要加载的属性</param> /// <returns>聚合根集合</returns> protected abstract PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties);
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="eagerLoadingProperties">聚合根实例需要加载的属性</param> /// <returns>聚合根集合</returns> protected abstract IQueryable <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties);
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="eagerLoadingProperties">聚合根实例需要加载的属性</param> /// <returns>聚合根集合</returns> protected virtual IQueryable <TAggregateRoot> DoFindAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { return(DoFindAll(new AnySpecification <TAggregateRoot>(), sortPredicate, sortOrder, eagerLoadingProperties)); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页数</param> /// <returns>聚合根集合</returns> protected abstract PagedResult <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize);
protected override IEnumerable <TAggregateRoot> DoGetAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { var results = this.DoFindAll(specification, sortPredicate, sortOrder, pageNumber, pageSize, eagerLoadingProperties); if (results == null || results.Count() == 0) { throw new ArgumentException("Aggregate not found."); } return(results); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="eagerLoadingProperties">聚合根实例需要加载的属性</param> /// <returns>聚合根集合</returns> public IQueryable <TAggregateRoot> FindAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { return(this.DoFindAll(sortPredicate, sortOrder, eagerLoadingProperties)); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <returns>The aggregate roots.</returns> protected override IQueryable <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { var query = efContext.Context.Set <TAggregateRoot>() .Where(specification.GetExpression()); if (sortPredicate != null) { switch (sortOrder) { case SortOrder.Ascending: return(query.SortBy(sortPredicate)); case SortOrder.Descending: return(query.SortByDescending(sortPredicate)); default: break; } } return(query); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页数</param> /// <param name="eagerLoadingProperties">聚合根实例需要加载的属性</param> /// <returns>聚合根集合</returns> public PagedResult <TAggregateRoot> FindAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { return(this.DoFindAll(sortPredicate, sortOrder, pageNumber, pageSize, eagerLoadingProperties)); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="eagerLoadingProperties">The properties for the aggregated objects that need to be loaded.</param> /// <returns>The aggregate root.</returns> protected override IQueryable <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { var dbset = efContext.Context.Set <TAggregateRoot>(); IQueryable <TAggregateRoot> queryable = null; if (eagerLoadingProperties != null && eagerLoadingProperties.Length > 0) { var eagerLoadingProperty = eagerLoadingProperties[0]; var eagerLoadingPath = this.GetEagerLoadingPath(eagerLoadingProperty); var dbquery = dbset.Include(eagerLoadingPath); for (int i = 1; i < eagerLoadingProperties.Length; i++) { eagerLoadingProperty = eagerLoadingProperties[i]; eagerLoadingPath = this.GetEagerLoadingPath(eagerLoadingProperty); dbquery = dbquery.Include(eagerLoadingPath); } queryable = dbquery.Where(specification.GetExpression()); } else { queryable = dbset.Where(specification.GetExpression()); } if (sortPredicate != null) { switch (sortOrder) { case SortOrder.Ascending: return(queryable.SortBy(sortPredicate)); case SortOrder.Descending: return(queryable.SortByDescending(sortPredicate)); default: break; } } return(queryable); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <returns>聚合根集合</returns> protected virtual IQueryable <TAggregateRoot> DoFindAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { return(DoFindAll(new AnySpecification <TAggregateRoot>(), sortPredicate, sortOrder)); }
protected override IEnumerable <TAggregateRoot> DoGetAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { var results = this.DoFindAll(specification, sortPredicate, sortOrder); if (results == null || results.Count() == 0) { throw new RepositoryException(Resources.EX_GETALL_FAIL); } return(results); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页数</param> /// <returns>聚合根集合</returns> protected virtual PagedResult <TAggregateRoot> DoFindAll(Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) { return(DoFindAll(new AnySpecification <TAggregateRoot>(), sortPredicate, sortOrder, pageNumber, pageSize)); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="eagerLoadingProperties">The properties for the aggregated objects that need to be loaded.</param> /// <returns>The aggregate root.</returns> protected override IQueryable <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, params Expression <Func <TAggregateRoot, dynamic> >[] eagerLoadingProperties) { return(this.DoFindAll(specification, sortPredicate, sortOrder)); }
/// <summary> /// 从仓储中查找所有的聚合根对象 /// </summary> /// <param name="specification">聚合根要匹配的规约</param> /// <param name="sortPredicate">用于排序的排序断言</param> /// <param name="sortOrder"><see cref="Storage.SortOrder"/>枚举类型,指定如何排序</param> /// <returns>聚合根集合</returns> protected abstract IQueryable <TAggregateRoot> DoFindAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder);
protected override IEnumerable <TAggregateRoot> DoGetAll(ISpecification <TAggregateRoot> specification, Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) { var results = this.DoFindAll(specification, sortPredicate, sortOrder); if (results == null || results.Count() == 0) { throw new RepositoryException("Cannot get the aggregate with the provided specification."); } return(results); }
/// <summary> /// Finds all the aggregate roots from repository. /// </summary> /// <param name="specification">The specification with which the aggregate roots should match.</param> /// <param name="sortPredicate">The sort predicate which is used for sorting.</param> /// <param name="sortOrder">The <see cref="Apworks.Storage.SortOrder"/> enumeration which specifies the sort order.</param> /// <param name="pageNumber">The number of objects per page.</param> /// <param name="pageSize">The number of objects per page.</param> /// <returns>The aggregate roots.</returns> public PagedResult <TAggregateRoot> FindAll <TAggregateRoot>(ISpecification <TAggregateRoot> specification, System.Linq.Expressions.Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder, int pageNumber, int pageSize) where TAggregateRoot : class, IAggregateRoot { EnsureSession(); if (pageNumber <= 0) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "The pageNumber is one-based and should be larger than zero."); } if (pageSize <= 0) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "The pageSize is one-based and should be larger than zero."); } if (sortPredicate == null) { throw new ArgumentNullException("sortPredicate"); } var query = this.session.Query <TAggregateRoot>() .Where(specification.GetExpression()); int skip = (pageNumber - 1) * pageSize; int take = pageSize; int totalCount = 0; int totalPages = 0; List <TAggregateRoot> pagedData = null; PagedResult <TAggregateRoot> result = null; switch (sortOrder) { case Storage.SortOrder.Ascending: totalCount = query.ToFutureValue(x => x.Count()).Value; totalPages = (totalCount + pageSize - 1) / pageSize; pagedData = query.OrderBy(sortPredicate).Skip(skip).Take(take).ToFuture().ToList(); result = new PagedResult <TAggregateRoot>(totalCount, totalPages, pageSize, pageNumber, pagedData); break; case Storage.SortOrder.Descending: totalCount = query.ToFutureValue(x => x.Count()).Value; totalPages = (totalCount + pageSize - 1) / pageSize; pagedData = query.OrderByDescending(sortPredicate).Skip(skip).Take(take).ToFuture().ToList(); result = new PagedResult <TAggregateRoot>(totalCount, totalPages, pageSize, pageNumber, pagedData); break; default: break; } // Use of implicit transactions is discouraged. // For more information please refer to: http://www.hibernatingrhinos.com/products/nhprof/learn/alert/DoNotUseImplicitTransactions Commit(); return(result); }
/// <summary> /// Gets a list of ordered objects from storage by given specification. /// </summary> /// <typeparam name="T">The type of the object to get.</typeparam> /// <param name="specification">The specification.</param> /// <param name="orders">The <c>PropertyBag</c> instance which contains the ordering fields.</param> /// <param name="sortOrder">The sort order.</param> /// <returns>A list of ordered objects.</returns> public IEnumerable <T> Select <T>(ISpecification <T> specification, PropertyBag orders, Storage.SortOrder sortOrder) where T : class, new() { IEnumerable <T> result; using (var connection = this.CreateDatabaseConnection()) { connection.Open(); result = DoSelect <T>(specification, orders, sortOrder, connection); connection.Close(); } return(result); }
public IQueryable <TAggregateRoot> FindAll <TAggregateRoot>(Specifications.ISpecification <TAggregateRoot> specification, System.Linq.Expressions.Expression <Func <TAggregateRoot, dynamic> > sortPredicate, Storage.SortOrder sortOrder) where TAggregateRoot : class, IAggregateRoot { EnsureSession(); IQueryable <TAggregateRoot> result = null; var query = this._session.Query <TAggregateRoot>() .Where(specification.Expression); switch (sortOrder) { case Storage.SortOrder.Ascending: if (sortPredicate != null) { result = query.OrderBy(sortPredicate); } break; case Storage.SortOrder.Descending: if (sortPredicate != null) { result = query.OrderByDescending(sortPredicate); } break; default: result = query; break; } Commit(); return(result); }