DDD领域模型查询方法实现（八）

在DDD.Domain工程文件夹Repository下创建RequestPage类：

public class RequestPage
{
public RequestPage(int pagesize, int currentpage, string orderproperty, string order)
{
this.PageSize = pagesize;
this.CurrentPage = currentpage;
this.Orderproperty = orderproperty;
this.Order = order;
}

public int PageSize { get; }
public int CurrentPage { get; }
public string Orderproperty { get; }
public string Order { get; }
}

在 Repository文件夹IRepository接口中定义：

//返回聚合根分页的方法
List<TAggreateRoot> GetByConditionPages(Expression<Func<TAggreateRoot, bool>> condition,
RequestPage request, out int totalcount);
List<TAggreateRoot> GetByConditionPages(List<Conditions> condition,
RequestPage request, out int totalcount);

List<TDTO> GetByConditionPages<TDTO>(Expression<Func<TAggreateRoot, bool>> condition,
RequestPage request, out int totalcount);
List<TDTO> GetByConditionPages<TDTO>(List<Conditions> condition,
RequestPage request, out int totalcount);

在DDD.Repository工程ResultPage类中：（结果集）

public class ResultPage<T> : IQueryable<T>
{
public ResultPage(int totalpages, int totalcounts, int currentpage, List<T> data)
{
this.TotalPages = totalpages;
this.TotalCounts = totalcounts;
this.CurrentPage = currentpage;
this.Data = data;
}

public int TotalPages { get; }
public int TotalCounts { get; }
public int Pagesize { get; }
public int CurrentPage { get; }
public List<T> Data { get; }

public Type ElementType
{
get
{
return typeof(T);

}
}

public Expression Expression
{
get;
}

public IQueryProvider Provider
{
get;
}

public IEnumerator<T> GetEnumerator()
{
return Data.GetEnumerator();
}

IEnumerator IEnumerable.GetEnumerator()
{
return Data.GetEnumerator();
}
}

在EFRepository中实现分页的方法：

public List<TAggreateRoot> GetByConditionPages(List<Conditions> condition, RequestPage request, out int totalcount)
{
return GetByConditionPages(WhereLamdaConverter.Where<TAggreateRoot>(condition), request, out totalcount);
}

public List<TAggreateRoot> GetByConditionPages(Expression<Func<TAggreateRoot, bool>> condition, RequestPage request, out int totalcount)
{
var query = orderdbcontext.Set<TAggreateRoot>().Where(condition);
var skip = (request.CurrentPage - 1) * request.PageSize;
var take = request.PageSize;
var queryresult =
request.Order == "ASC" ? query.OrderBy(p => new { Order = request.Orderproperty })
.Skip(skip).Take(take) :
query.OrderByDescending(p => new { Order = request.Orderproperty })
.Skip(skip).Take(take);
totalcount = query.Count();

return new ResultPage<TAggreateRoot>(totalcount / request.PageSize, totalcount,
request.CurrentPage, queryresult.ToList()).ToList();
}

public List<TDTO> GetByConditionPages<TDTO>(List<Conditions> condition, RequestPage request, out int totalcount)
{
return GetByConditionPages<TDTO>(WhereLamdaConverter.Where<TAggreateRoot>(condition), request, out totalcount);
}

public List<TDTO> GetByConditionPages<TDTO>(Expression<Func<TAggreateRoot, bool>> condition, RequestPage request, out int totalcount)
{
var query = orderdbcontext.Set<TAggreateRoot>().Where(condition);
var skip = (request.CurrentPage - 1) * request.PageSize;
var take = request.PageSize;
var queryresult =
request.Order == "ASC" ? query.OrderBy(p => new { Order = request.Orderproperty })
.Skip(skip).Take(take) :
query.OrderByDescending(p => new { Order = request.Orderproperty })
.Skip(skip).Take(take);
totalcount = query.Count();
var queryresults = queryresult.ToList();
var queryresultdtos = new List<TDTO>();
if (totalcount > 0)
{
foreach (var q in queryresults)
{
var queryresultdto = Mapper.Map<TAggreateRoot, TDTO>(q);
queryresultdtos.Add(queryresultdto);
}
}
return new ResultPage<TDTO>(totalcount / request.PageSize, totalcount, request.CurrentPage,
queryresultdtos).ToList();
}

在DDD.Infrastructure中新建LamdaFilterConvert（做筛选的转化器）：--Conditions

public class Conditions
{
//具体插叙的字段
public string Field { get; set; }
//操作符
public string Operator { get; set; }
//字段的值
public string Value { get; set; }
//字段查询组合的关系
public string Relation { get; set; }
//把界面传的值转成List集合
public static List<Conditions> BuildConditions(string[] fields, string[] operators, string[] values,
string[] relations)
{
var conditions = fields.Select((t, i) => new Conditions
{
Field = t,
Operator = operators[i],
Value = values[i],
Relation = relations[i]
}).ToList();
return conditions;
}
}

带有where的Lambda表达式转换器：

public static class WhereLamdaConverter
{
private class ParameterReplacer : ExpressionVisitor
{
public ParameterExpression ParameterExpression { get; private set; }

public ParameterReplacer(ParameterExpression paramExp)
{
this.ParameterExpression = paramExp;
}

public Expression Replace(Expression exp)
{
return this.Visit(exp);
}

protected override Expression VisitParameter(ParameterExpression p)
{
return this.ParameterExpression;
}
}

public static Expression<Func<T, bool>> True<T>()
{
return item => true;
}

public static Expression<Func<T, bool>> False<T>()
{
return item => false;
}

public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expLeft, Expression<Func<T, bool>> expRight)
{
var candidateExpr = Expression.Parameter(typeof(T), "item");
var parameterReplacer = new ParameterReplacer(candidateExpr);

var left = parameterReplacer.Replace(expLeft.Body);
var right = parameterReplacer.Replace(expRight.Body);
var body = Expression.And(left, right);

return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
}

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expLeft, Expression<Func<T, bool>> expRight)
{
var candidateExpr = Expression.Parameter(typeof(T), "item");
var parameterReplacer = new ParameterReplacer(candidateExpr);
var left = parameterReplacer.Replace(expLeft.Body);
var right = parameterReplacer.Replace(expRight.Body);
var body = Expression.Or(left, right);
return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
}
public static Expression<Func<T, bool>> Parse<T>(string member, string logic, string matchValue)
{
if (string.IsNullOrEmpty(member))
{
throw new ArgumentNullException("member");
}
PropertyInfo keyProperty;
ParameterExpression pExp;
keyProperty = typeof(T).GetProperties().FirstOrDefault(item => item.Name.ToLower().Equals(member.Trim().ToLower()));
pExp = Expression.Parameter(typeof(T), "p");

if (keyProperty == null)
{
throw new ArgumentException("member不存在");
}

Expression memberExp = Expression.MakeMemberAccess(pExp, keyProperty);
if (logic != "Contains")
{
bool memberIsNullableType = keyProperty.PropertyType.IsGenericType && keyProperty.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>);

if (memberIsNullableType)
{
memberExp = Expression.MakeMemberAccess(memberExp, keyProperty.PropertyType.GetProperty("Value"));
}

Type valueType = keyProperty.PropertyType;
if (memberIsNullableType == true)
{
valueType = valueType.GetGenericArguments().FirstOrDefault();
}

object value = matchValue;
if (valueType == typeof(string) == false)
{
if (valueType != null)
value = valueType.GetMethod("Parse", new[] { typeof(string) }).Invoke(null, new[] { value });
}

var valueExp = Expression.Constant(value, valueType);

var expMethod = typeof(Expression).GetMethod(logic, new Type[] { typeof(Expression), typeof(Expression) });

var body = expMethod.Invoke(null, new object[] { memberExp, valueExp }) as Expression;
var lamdaexpression = Expression.Lambda(body, pExp) as Expression<Func<T, bool>>;
return lamdaexpression;
}
else
{
MethodCallExpression body = null;
body = Expression.Call(memberExp, typeof(string).GetMethod(logic), Expression.Constant(matchValue, typeof(string)));
var lamdaexpression = Expression.Lambda(body, pExp) as Expression<Func<T, bool>>;
return lamdaexpression;
}
}

public static Expression<Func<T, bool>> Where<T>(List<Conditions> conditions)
{
Expression<Func<T, bool>> expression = null;
if (conditions != null && conditions.Count > 0)
{
var firstexpression =
Parse<T>(conditions[0].Field, conditions[0].Operator, conditions[0].Value);
if (conditions.Count <= 1)
return firstexpression;
for (var i = 1; i < conditions.Count; i++)
{
var rightexpression =
Parse<T>(conditions[i].Field, conditions[i].Operator, conditions[i].Value);
expression = conditions[i - 1].Relation.ToUpper().Equals("AND")
? firstexpression.And(rightexpression)
: firstexpression.Or(rightexpression);
}
}
return expression;
}

}

把映射的代码移到DDD.Application工程ProductAppService类中：

IRepository<Product> productrepository = ServiecLocator.Instance.GetService(typeof(IRepository<Product>))
as IRepository<Product>;

Product product;
//public void CreateProduct(string productname, string color, string size,
//    int count, decimal unitprice, string categoryname, string description)
//{
//    product.CreateProduct(productname, color, size, count, unitprice, categoryname, description);
//    context.Commit();
//}

public ProductAppService()
{
product = new Product(productrepository);
//完成映射的创建
ProductMapping();
}
//在调用构造函数的时候完成映射的创建
private void ProductMapping()
{
//从界面的DTO持久化领域对象
var mapin = Mapper.CreateMap<ProductDTO, Product>();
//指定属性的对应关系
mapin.ConstructProjectionUsing(p => new Product
{
ProductName = p.Name,
Size = p.Size,
Color = p.Color,
Count = p.Amount,
UnitPrice = p.UnitPrice,
ProductCategory = new ProductCategory
{
Id = Guid.NewGuid(),
CategoryName = p.PCategoryName,
Description = p.PDescription
}
});
//返回界面的东西
var mapout = Mapper.CreateMap<Product, ProductDTO>();
mapout.ConstructProjectionUsing(p => new ProductDTO
{
Name = p.ProductName,
Size = p.Size,
Color = p.Color,
UnitPrice = p.UnitPrice,
PCategoryName = p.ProductCategory.CategoryName,
PDescription = p.ProductCategory.Description,
Amount = p.Count
});
}

/// <summary>
/// 被前端调用的方法
/// </summary>
/// <param name="conditions"></param>
/// <param name="request"></param>
/// <param name="totalcount"></param>
/// <returns></returns>
public List<ProductDTO> GetProductDTOSByCondition(List<Conditions> conditions,
RequestPage request, out int totalcount)
{
return productrepository.GetByConditionPages<ProductDTO>(conditions, request,
out totalcount);
}