public static Expression <Func <B> > BindInput(Expression <Func <A, B> > expression, A input)
{
var parameter = expression.Parameters.Single();
var visitor = new MyExpressionVisitor(parameter, input);
return(Expression.Lambda <Func <B> >(visitor.Visit(expression.Body)));
}
public IEnumerable <RoleEntity> GetAllByPredicate(Expression <Func <RoleEntity, bool> > f)
{
var visitor = new MyExpressionVisitor <RoleEntity, DalRole>(Expression.Parameter(typeof(DalRole), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <DalRole, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
return(roleRepository.GetAllByPredicate(exp2).Select(r => r.GetBllEntity()));
}
public static void SetValue(object target, Expression memberExpr, object value, bool isList)
{
var type = target.GetType();
var objParam = Parameter(typeof(object), "obj");
memberExpr = new MyExpressionVisitor(Convert(objParam, type)).Visit(memberExpr);
Action <object> action;
if (isList)
{
var itemType = memberExpr.Type.GetGenericArguments()[0];
var listType = typeof(List <>).MakeGenericType(itemType);
action = Lambda <Action <object> >(
Block(
IfThen(
Equal(memberExpr, Constant(null)),
Assign(memberExpr, New(listType))
),
Call(Convert(memberExpr, listType), listType.GetMethod("Add"), Constant(value))
),
objParam
).Compile();
}
else
{
action = Lambda <Action <object> >(Assign(memberExpr, Constant(value)), objParam).Compile();
}
action(target);
}
public UserEntity GetOneByPredicate(Expression <Func <UserEntity, bool> > f)
{
var visitor = new MyExpressionVisitor <UserEntity, DalUser>(Expression.Parameter(typeof(DalUser), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <DalUser, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
return(userRepository.GetOneByPredicate(exp2).GetBllEntity());
}
public IEnumerable <UserEntity> GetAllByPredicate(Expression <Func <UserEntity, bool> > f)
{
var visitor = new MyExpressionVisitor <UserEntity, DalUser>(Expression.Parameter(typeof(DalUser), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <DalUser, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
//ToList()
return(userRepository.GetAllByPredicate(exp2).Select(user => user.GetBllEntity()).ToList());
}
public IEnumerable <MissionEntity> GetAllByPredicate(Expression <Func <MissionEntity, bool> > f)
{
var visitor = new MyExpressionVisitor <MissionEntity, DalMission>(Expression.Parameter(typeof(DalMission), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <DalMission, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
var mission = missionRepository.GetAllByPredicate(exp2).ToList();
return(mission.Select(m => m.GetBllEntity()));
}
public IEnumerable <DalTask> GetAllByPredicate(Expression <Func <DalTask, bool> > f)
{
var visitor = new MyExpressionVisitor <DalTask, Task>(Expression.Parameter(typeof(Task), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <Task, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
var tasks = context.Set <Task>().Where(exp2).ToList();
return(tasks.Select(task => task.GetDalEntity()));
}
///// <summary>
///// 使用 OR 逻辑符号拼接表达式树
///// </summary>
//public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
//{
// var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
// return Expression.Lambda<Func<T, bool>>(Expression.Or(expr1.Body, invokedExpr), expr1.Parameters);
//}
///// <summary>
///// 使用 AND 逻辑符号拼接表达式树
///// </summary>
//public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
//{
// var invokedExpr = Expression.Invoke(expr1, expr2.Parameters.Cast<Expression>());
// return Expression.Lambda<Func<T, bool>>(Expression.And(expr2.Body, invokedExpr), expr2.Parameters);
//}
private static Expression <T> Combine <T>(this Expression <T> first, Expression <T> second, Func <Expression, Expression, Expression> merge)
{
MyExpressionVisitor visitor = new MyExpressionVisitor(first.Parameters[0]);
Expression bodyone = visitor.Visit(first.Body);
Expression bodytwo = visitor.Visit(second.Body);
return(Expression.Lambda <T>(merge(bodyone, bodytwo), first.Parameters[0]));
}
public IEnumerable <DalUser> GetAllByPredicate(Expression <Func <DalUser, bool> > f)
{
var visitor = new MyExpressionVisitor <DalUser, User>(Expression.Parameter(typeof(User), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <User, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
var x = context.Set <User>().Include(user => user.Roles).Where(exp2).ToList();
return(x.Select(user => user.GetDalEntity()));
}
public IEnumerable <DalMission> GetAllByPredicate(Expression <Func <DalMission, bool> > f)
{
var visitor = new MyExpressionVisitor <DalMission, Mission>(Expression.Parameter(typeof(Mission), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <Mission, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
var x = context.Set <Mission>().Where(exp2).ToList();
return(x.Select(mis => mis.GetDalEntity()));
}
public ExpressionHelper <T> Or(Expression <Func <T, bool> > expr)
{
var visitor = new MyExpressionVisitor(_pe);
var replaceSource = visitor.ReplaceVars(_source);
var replaceDest = visitor.ReplaceVars(expr);
_source = Expression.Lambda <Func <T, bool> >(Expression.Or(replaceSource.Body, replaceDest.Body), _pe);
return(this);
}
public IEnumerable <DalRole> GetAllByPredicate(Expression <Func <DalRole, bool> > f)
{
var visitor =
new MyExpressionVisitor <DalRole, Role>(Expression.Parameter(typeof(Role), f.Parameters[0].Name));
var exp2 = Expression.Lambda <Func <Role, bool> >(visitor.Visit(f.Body), visitor.NewParameterExp);
return(context.Set <Role>()
.Where(exp2)
.Select(r => r.GetDalEntity()));
}
public static void SetValue(object target, Expression memberExpr, object value)
{
var type = target.GetType();
var objParam = Expression.Parameter(typeof(object), "obj");
memberExpr = new MyExpressionVisitor(Expression.Convert(objParam, type)).Visit(memberExpr);
Expression.Lambda <Action <object> >(Expression.Assign(memberExpr, Expression.Constant(value)), objParam).Compile()(target);
}
public static Expression <Func <T, bool> > Or <T>(this Expression <Func <T, bool> > exp1, Expression <Func <T, bool> > exp2)
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "a");
MyExpressionVisitor visitor = new MyExpressionVisitor(parameterExpression);
var left = visitor.Replace(exp1.Body);
var right = visitor.Replace(exp2.Body);
var newBody = Expression.Or(left, right);
return(Expression.Lambda <Func <T, bool> >(newBody, parameterExpression));
}
public static T FirstOrDefault <T>(Expression <Func <T, bool> > expression) where T : class
{
var visit = new MyExpressionVisitor();
visit.Visit(expression);
var sqlWhere = visit.WhereMarkUp <T>();
var tableAttr = GetTableAttribute <T>();
var sql = SqlReplaceWhiteSpace($"Select Top 1 * from {tableAttr.TableName}{ sqlWhere} ;");
IList <T> result = GetFillDataSet <T>(sql);
return(result.FirstOrDefault());
}
public static bool Update <T>(Expression <Func <T, bool> > expression, dynamic updateObj) where T : class
{
var visit = new MyExpressionVisitor();
visit.Visit(expression);
var sqlWhere = visit.WhereMarkUp <T>();
var tableAttr = GetTableAttribute <T>();
var setParam = GetSetParam(updateObj);
var sql = SqlReplaceWhiteSpace($"Update {tableAttr.TableName} Set {setParam}{ sqlWhere} ;");
var res = DBHelper.ExecuteNonQuery(sql);
return(res > 0 ? true : false);
}
public static int Count <T>(Expression <Func <T, bool> > expression)
{
var visit = new MyExpressionVisitor();
visit.Visit(expression);
var sqlWhere = visit.WhereMarkUp <T>();
var tableAttr = GetTableAttribute <T>();
var sql = SqlReplaceWhiteSpace($"Select Count(*) from {tableAttr.TableName}{ sqlWhere} ;");
var result = DBHelper.ExecuteScalar(sql);
var count = Convert.ToInt32(result);
return(count);
}
public void TestToFail_TestToFail()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
BinaryExpression ExpressionTree = null;
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
string TestToPassExpression = "1 + 1";
//Act
ExpressionTree = calculateExpression.CalculateValidExpression(TestToPassExpression, ExpressionTree, myExpressionVisitor);
var results = Expression.Lambda(ExpressionTree).Compile().DynamicInvoke();
//Assert
Assert.Fail();
}
public void TestBoundaries()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
BinaryExpression ExpressionTree = null;
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
string TestToPassExpression = "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 1 +";
//Act
ExpressionTree = calculateExpression.CalculateValidExpression(TestToPassExpression, ExpressionTree, myExpressionVisitor);
var results = Expression.Lambda(ExpressionTree).Compile().DynamicInvoke();
//Assert
Assert.AreEqual(1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00, results);
}
public void TestToFail_DivideByZero()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
Validation validation = new Validation();
string TestToFailExpression = "1 1 + 0 /";
bool IsValidExpression = false;
//Act
bool results = validation.IsValid(TestToFailExpression, IsValidExpression);
//Assert
Assert.AreEqual(false, results);
}
static void Main(string[] args)
{
Expression <Func <DateTime, double> > abc = v => 1.0d * v.Ticks / (v.Month + v.Minute);
MyExpressionVisitor mev = new MyExpressionVisitor(DateTime.Now);
var ret = mev.Visit(abc);
}
/// <inheritdoc />
protected override void VisitCore(MethodCallExpression node)
{
switch (node.Method.Name)
{
case MethodCall.DefaultIfEmpty:
if (hasDefaultValue)
{
throw new NotSupportedException($"函数“{node.Method.Name}”仅在表达式链最多只能出现一次！");
}
if (node.Arguments.Count > 1)
{
defaultValue = node.Arguments[1].GetValueFromExpression();
}
hasDefaultValue = true;
Visit(node.Arguments[0]);
break;
case MethodCall.Min:
case MethodCall.Max:
case MethodCall.Average:
rowStyle = RowStyle.Single;
base.VisitCore(node);
if (node.Arguments.Count == 1)
{
break;
}
if (hasDefaultValue)
{
if (defaultValue is null)
{
if (node.Type.IsValueType && !node.Type.IsNullable())
{
throw new NotSupportedException($"表达式“{node}”不能从默认值“null”中获取数据!");
}
}
else
{
var argType = node.Arguments[0].Type.GetGenericArguments()[0];//? 获取泛型参数。
var defaultType = defaultValue.GetType();
var parameterExp = Expression.Parameter(argType);
//? 获取表达式值。
var expression = new MyExpressionVisitor(parameterExp)
.Visit(node.Arguments[1]);
if (argType == defaultType || defaultType.IsAssignableFrom(argType))
{
defaultValue = expression.GetValueFromExpression(defaultValue);
}
else
{
throw new InvalidCastException($"无法从“{argType}”转换为“{defaultType}”类型!");
}
}
}
isAverage = node.Method.Name == MethodCall.Average;
break;
case MethodCall.Last:
case MethodCall.First:
rowStyle = RowStyle.First;
goto default;
case MethodCall.LastOrDefault:
case MethodCall.FirstOrDefault:
rowStyle = RowStyle.FirstOrDefault;
goto default;
case MethodCall.Single:
case MethodCall.ElementAt:
rowStyle = RowStyle.Single;
goto default;
case MethodCall.SingleOrDefault:
case MethodCall.ElementAtOrDefault:
rowStyle = RowStyle.SingleOrDefault;
goto default;
default:
base.VisitCore(node);
break;
}
}
