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