/// <summary>
/// 更新缓存
/// </summary>
/// <param name="assign">赋值表达式树</param>
/// <param name="whereExp">条件</param>
private int UpdateCache(Expression assign, params Expression <Func <TEntity, bool> >[] whereExp)
{
// 更新本地缓存（立即执行，在事务中延迟会数据不同步）
// 缓存库中的所有数据
var lstCacheLibrary = Cache.ToList();
// 筛选出要更新的数据列表
var lstUpdate = whereExp.Aggregate(lstCacheLibrary, (current, exp) => current.FindAll(new Predicate <TEntity>(exp.Compile())));
// 筛选条件
if (!lstUpdate.Any())
{
return(0);
}
// 获取赋值表达式树中的每一项操作赋值符号树
var lstLambda = new GetBinaryVisitor().Visit(assign);
foreach (var ex in lstLambda)
{
// 转换成Lambda表达式（用于下面的传入执行）
// 获取实体类的表达式参数
var entityParamter = new GetParamVisitor().Visit(ex).FirstOrDefault();
var lambda = Expression.Lambda <Action <TEntity> >(ex, entityParamter).Compile();
foreach (var updateEntity in lstUpdate)
{
lambda(updateEntity);
}
}
// 更新到接口操作的缓存保存中
_dataCache.Update(lstCacheLibrary);
return(lstCacheLibrary.Count);
}
/// <summary>
/// 添加或者减少某个字段（支持延迟加载）
/// </summary>
public void AddUp()
{
var assign = _set.Queue.ExpBuilder.ExpAssign;
var exp = (Expression <Func <TEntity, bool> >)_set.Queue.ExpBuilder.ExpWhere;
_set.AddUp();
// 更新本地缓存
_set.QueueManger.AppendLazy(_set.Name, _set.SetState, (queue) =>
{
var lst = Cache;
if (exp != null)
{
lst = lst.ToList().FindAll(exp.Compile().ToPredicate());
}
// 获取可以转换成Lambda的表达式树
var lstLambda = new GetBinaryVisitor().Visit(assign);
foreach (var ex in lstLambda)
{
// 获取现有参数表达式树
var paramter = new GetParamVisitor().Visit(ex).FirstOrDefault();
// 转换成Lambda表达式
var lambda = Expression.Lambda <Action <TEntity> >(ex, paramter).Compile();
foreach (var updateEntity in lst)
{
lambda(updateEntity);
}
}
}, !_set.Context.IsMergeCommand, false);
}
/// <summary>
/// 动态创建一个 o.ID == value的表达式树
/// </summary>
/// <typeparam name="TEntity">实体</typeparam>
/// <param name="val">右值</param>
/// <param name="expType">匹配符号类型</param>
/// <param name="memberName">左边ID成员名称</param>
public static Expression <Func <TEntity, bool> > CreateBinaryExpression <TEntity>(object val, MemberExpression memberName, ExpressionType expType = ExpressionType.Equal) where TEntity : class, new()
{
var oParam = new GetParamVisitor().Visit(memberName).FirstOrDefault();
var right = Expression.Convert(Expression.Constant(val), memberName.Type);
BinaryExpression where = null;
switch (expType)
{
case ExpressionType.Equal:
where = Expression.Equal(memberName, right);
break;
case ExpressionType.NotEqual:
where = Expression.NotEqual(memberName, right);
break;
case ExpressionType.GreaterThan:
where = Expression.GreaterThan(memberName, right);
break;
case ExpressionType.GreaterThanOrEqual:
where = Expression.GreaterThanOrEqual(memberName, right);
break;
case ExpressionType.LessThan:
where = Expression.LessThan(memberName, right);
break;
case ExpressionType.LessThanOrEqual:
where = Expression.LessThanOrEqual(memberName, right);
break;
}
return((Expression <Func <TEntity, bool> >)Expression.Lambda(where, oParam));
}
static void Main(string[] args)
{
Expression <Func <UserVO, object> > fieldName = o => new { o.ID, o.LogCount, o.LoginIP };
var type = new GetParamVisitor().Visit(fieldName).Select(o => o.Type).First();
Table.Data.UserRole.AddUp(1, o => o.UserCount, 1);
SpeedTest.Initialize();
//TestTableInstance(1);
//TestSetValueCache(1);
//TestGetValueCache(1);
//TestToList(1);
Console.Clear();
//Console.WriteLine("请按任意键开始测试");
//Console.ReadKey();
//Console.Clear();
//#if DEBUG
// Console.WriteLine("请在Release模式下进行");
// Console.ReadKey();
// return;
//#endif
//TestTableInstance();
//TestSetValueCache();
//TestGetValueCache();
//TestToList();
TestDynamicClass();
Console.ReadKey();
}
/// <summary>
/// 动态创建一个 List.Contains(o.ID)的表达式树
/// </summary>
/// <typeparam name="TEntity">实体</typeparam>
/// <param name="val">右值</param>
/// <param name="memberName">左边ID成员名称</param>
public static Expression <Func <TEntity, bool> > CreateContainsBinaryExpression <TEntity>(object val, MemberExpression memberName) where TEntity : class, new()
{
var oParam = new GetParamVisitor().Visit(memberName).FirstOrDefault();
var member = memberName.Type.IsGenericType && memberName.Type.GetGenericTypeDefinition() == typeof(Nullable <>) ? (Expression)Expression.Call(memberName, memberName.Type.GetMethod("GetValueOrDefault", new Type[] { })) : memberName;
var right = Expression.Constant(val, val.GetType());
var where = Expression.Call(right, right.Type.GetMethod("Contains"), member);
return((Expression <Func <TEntity, bool> >)Expression.Lambda(where, oParam));
}
/// <summary>
/// 合并NewExpression
/// </summary>
/// <param name="exps">要合并的NewExpression</param>
public static Expression MergeNewExpression(params Expression[] exps)
{
// 获取表达式树中实体类型
var parentType = new GetParamVisitor().Visit(exps[0]).Select(o => o.Type).First();
// 取得所有PropertyInfo
var lst = new GetMemberVisitor().Visit(exps).Select(o => (PropertyInfo)o.Member);
// 构造函数参数类型
var lstPropertyType = lst.Select(o => o.PropertyType).ToArray();
// 根据取得的PropertyInfo列表，创建新类型
var classType = CacheManger.CreateClass(null, lstPropertyType, parentType);
// 获取新类型的构造函数
var constructor = classType.GetConstructor(lstPropertyType);
// 创建构造函数的参数表达式数组
var constructorParam = BuildConstructorsParameters(classType, lst);
return(Expression.New(constructor, constructorParam));
}
