/// <summary> /// 获取Lambda表达式返回的结果 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="func"></param> /// <returns></returns> public CoreFrameworkEntity GetLambdaEntity <T>(System.Linq.Expressions.Expression <Func <T, bool> > func) { if (func == null) { return(null); } listPara.Clear(); CoreFrameworkEntity lambdaEntity = new CoreFrameworkEntity(); // 二元运算符表达式 if (func.Body is System.Linq.Expressions.BinaryExpression) { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)func.Body); lambdaEntity.Where = BinarExpressionProvider(be.Left, be.Right, be.NodeType); lambdaEntity.ParaList = listPara; } // 单纯的静态方法 if (func.Body is System.Linq.Expressions.MethodCallExpression) { System.Linq.Expressions.MethodCallExpression be = ((System.Linq.Expressions.MethodCallExpression)func.Body); lambdaEntity.Where = ExpressionRouter(be); lambdaEntity.ParaList = listPara; } return(lambdaEntity); }
// BinaryExpression: AndAlso, OrElse private Result RewriteLogicalBinaryExpression(Expression expr, Stack stack) { BinaryExpression node = (BinaryExpression)expr; // Left expression runs on a stack as left by parent Result left = RewriteExpression(node.Left, stack); // ... and so does the right one Result right = RewriteExpression(node.Right, stack); //conversion is a lambda. stack state will be ignored. Result conversion = RewriteExpression(node.Conversion, stack); RewriteAction action = left.Action | right.Action | conversion.Action; if (action != RewriteAction.None) { // We don't have to worry about byref parameters here, because the // factory doesn't allow it (it requires identical parameters and // return type from the AndAlso/OrElse method) expr = BinaryExpressionStubs.Create( node.NodeType, left.Node, right.Node, node.Type, node.Method, (LambdaExpression)conversion.Node ); } return(new Result(action, expr)); }
/// <summary> /// Converts a LINQ binary expression into the Infer.NET equivalent. /// </summary> /// <param name="binaryExpression"></param> /// <returns></returns> private IExpression ConvertBinary(System.Linq.Expressions.BinaryExpression binaryExpression) { return(Builder.BinaryExpr(Convert(binaryExpression.Left), ConvertBinaryOp(binaryExpression.NodeType), Convert(binaryExpression.Right) )); }
// https://stackoverflow.com/questions/321650/how-do-i-set-a-field-value-in-an-c-sharp-expression-tree public static void SetProperty111 <TTarget, TValue>(TTarget target, string fieldName, TValue newValue) { // Class in which to set value System.Linq.Expressions.ParameterExpression targetExp = System.Linq.Expressions.Expression.Parameter(typeof(TTarget), "target"); // Object's type: System.Linq.Expressions.ParameterExpression valueExp = System.Linq.Expressions.Expression.Parameter(typeof(TValue), "value"); // Expression.Property can be used here as well System.Linq.Expressions.MemberExpression memberExp = // System.Linq.Expressions.Expression.Field(targetExp, fieldName); // System.Linq.Expressions.Expression.Property(targetExp, fieldName); System.Linq.Expressions.Expression.PropertyOrField(targetExp, fieldName); System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(valueExp, memberExp.Type); System.Linq.Expressions.BinaryExpression assignExp = //System.Linq.Expressions.Expression.Assign(memberExp, valueExp); // Without conversion System.Linq.Expressions.Expression.Assign(memberExp, conversionExp); System.Action <TTarget, TValue> setter = System.Linq.Expressions.Expression .Lambda <System.Action <TTarget, TValue> >(assignExp, targetExp, valueExp).Compile(); setter(target, newValue); }
// BinaryExpression private Result RewriteBinaryExpression(Expression expr, Stack stack) { BinaryExpression node = (BinaryExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, 3); // Left expression executes on the stack as left by parent cr.Add(node.Left); // Right expression always has non-empty stack (left is on it) cr.Add(node.Right); // conversion is a lambda, stack state will be ignored cr.Add(node.Conversion); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNoRefArgs(node.Method); #else MarkRefArgs(cr, node.Method, 0); #endif } return(cr.Finish(cr.Rewrite ? BinaryExpressionStubs.Create( node.NodeType, cr[0], cr[1], node.Type, node.Method, (LambdaExpression)cr[2]) : expr)); }
/// <summary> /// The NotEqual is not really a binaryOperator, because is a unary (NOT) applyed to binary (equal) /// so the base factory cannot return a binary, the factory return a standard equal so it /// is duty of the caller verify that is a not /// </summary> /// <param name="b"></param> protected override void PVisitBinary(System.Linq.Expressions.BinaryExpression b) { Push(walkerFactory.FromBinary(b)); if (b.NodeType == System.Linq.Expressions.ExpressionType.NotEqual) { Push(walkerFactory.Not()); } base.PVisitBinary(b); }
/// <summary> /// 表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> string ExpressionRouter(System.Linq.Expressions.Expression exp) { //获取实体列的特性 List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>(); string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符 { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MemberExpression)//成员 { System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp); return(me.Member.Name); } else if (exp is System.Linq.Expressions.NewArrayExpression)//数组 { System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp); StringBuilder tmpstr = new StringBuilder(); foreach (System.Linq.Expressions.Expression ex in ae.Expressions) { tmpstr.Append(ExpressionRouter(ex)); tmpstr.Append(","); } return(tmpstr.ToString(0, tmpstr.Length - 1)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else if (exp is System.Linq.Expressions.ConstantExpression) { System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp); if (ce.Value == null) { return("null"); } else if (ce.Value is ValueType) { return(ce.Value.ToString()); } else if (ce.Value is string || ce.Value is DateTime || ce.Value is char) { return(string.Format("{0}", ce.Value.ToString())); } } else if (exp is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp); return(ExpressionRouter(ue.Operand)); } return(null); }
protected override System.Linq.Expressions.Expression VisitBinary(System.Linq.Expressions.BinaryExpression b) { this._CurrentMemberInfo = null; this._strSql.Append("("); this.Visit(b.Left); this._LastestOperator = new System.Linq.Expressions.ExpressionType?(b.NodeType); this._strSql.Append(" " + DMSOperators.FormatBinaryOperator(this._LastestOperator) + " "); this.Visit(b.Right); this._strSql.Append(")"); return(b); }
public static System.Linq.Expressions.Expression ReduceUserdefinedLifted(this System.Linq.Expressions.BinaryExpression obj) { try { return((System.Linq.Expressions.Expression)s_2.Invoke(obj, new object[0])); } catch (TargetInvocationException ex) { throw ex.InnerException; } }
public static System.Boolean get_IsLiftedLogical(this System.Linq.Expressions.BinaryExpression obj) { try { return((System.Boolean)s_1.GetValue(obj)); } catch (TargetInvocationException ex) { throw ex.InnerException; } }
private static System.Func <T, T, T> CompileAdd <T>() { // Declare the parameters System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Add the parameters System.Linq.Expressions.BinaryExpression body = System.Linq.Expressions.Expression.Add(paramA, paramB); // Compile it System.Func <T, T, T> add = System.Linq.Expressions.Expression.Lambda <System.Func <T, T, T> > (body, paramA, paramB).Compile(); return(add); }
private static System.Func <T, T, T> CompileSubtract <T>() { // Declare the parameters System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Subtract the parameters System.Linq.Expressions.BinaryExpression body = System.Linq.Expressions.Expression.Subtract(paramA, paramB); // Compile it System.Func <T, T, T> subtract = System.Linq.Expressions.Expression.Lambda <System.Func <T, T, T> > (body, paramA, paramB).Compile(); return(subtract); }
// BinaryExpression: AndAlso, OrElse private Result RewriteLogicalBinaryExpression(Expression expr, Stack stack) { BinaryExpression node = (BinaryExpression)expr; // Left expression runs on a stack as left by parent Result left = RewriteExpression(node.Left, stack); // ... and so does the right one Result right = RewriteExpression(node.Right, stack); //conversion is a lambda. stack state will be ignored. Result conversion = RewriteExpression(node.Conversion, stack); RewriteAction action = left.Action | right.Action | conversion.Action; if (action != RewriteAction.None) { // We don't have to worry about byref parameters here, because the // factory doesn't allow it (it requires identical parameters and // return type from the AndAlso/OrElse method) expr = BinaryExpressionStubs.Create( node.NodeType, left.Node, right.Node, node.Type, node.Method, (LambdaExpression)conversion.Node ); #if !LINQ /* * CONSIDER: Move logic to reduce logical binary nodes from the Reducer to the stack spiller. * * switch (expr.NodeType) * { * case ExpressionType.AndAlso: * case ExpressionType.OrElse: * expr = Microsoft.CSharp.Expressions.Compiler.Reducer.ReduceLogical((BinaryExpression)expr); * break; * case ExpressionType.Coalesce: * expr = Microsoft.CSharp.Expressions.Compiler.Reducer.ReduceCoalesce((BinaryExpression)expr); * break; * } */ #endif } return(new Result(action, expr)); }
//public static System.Action<T, object> GetSetter<T>(string fieldName) public static Setter_t <T> GetSetter <T>(string fieldName) { // Class in which to set value System.Linq.Expressions.ParameterExpression targetExp = System.Linq.Expressions.Expression.Parameter(typeof(T), "target"); // Object's type: System.Linq.Expressions.ParameterExpression valueExp = System.Linq.Expressions.Expression.Parameter(typeof(object), "value"); // Expression.Property can be used here as well System.Linq.Expressions.MemberExpression memberExp = null; try { // memberExp = System.Linq.Expressions.Expression.Field(targetExp, fieldName); // memberExp = System.Linq.Expressions.Expression.Property(targetExp, fieldName); memberExp = System.Linq.Expressions.Expression.PropertyOrField(targetExp, fieldName); } catch (System.Exception ex) { return(null); } // http://www.dotnet-tricks.com/Tutorial/linq/RJX7120714-Understanding-Expression-and-Expression-Trees.html System.Linq.Expressions.ConstantExpression targetType = System.Linq.Expressions.Expression.Constant(memberExp.Type); // http://stackoverflow.com/questions/913325/how-do-i-make-a-linq-expression-to-call-a-method System.Linq.Expressions.MethodCallExpression mce = System.Linq.Expressions.Expression.Call(m_FlexibleChangeType, valueExp, targetType); //System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(valueExp, memberExp.Type); System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(mce, memberExp.Type); System.Linq.Expressions.BinaryExpression assignExp = // System.Linq.Expressions.Expression.Assign(memberExp, valueExp); // Without conversion System.Linq.Expressions.Expression.Assign(memberExp, conversionExp); // System.Action<TTarget, TValue> setter = System.Linq.Expressions.Expression // System.Action<T, object> setter = System.Linq.Expressions.Expression // .Lambda<System.Action<T, object>>(assignExp, targetExp, valueExp).Compile(); Setter_t <T> setter = System.Linq.Expressions.Expression .Lambda <Setter_t <T> >(assignExp, targetExp, valueExp).Compile(); return(setter); } // End Function GetGetter
static void MakeBinary() { // <Snippet8> // Create a BinaryExpression that represents subtracting 14 from 53. System.Linq.Expressions.BinaryExpression binaryExpression = System.Linq.Expressions.Expression.MakeBinary( System.Linq.Expressions.ExpressionType.Subtract, System.Linq.Expressions.Expression.Constant(53), System.Linq.Expressions.Expression.Constant(14)); Console.WriteLine(binaryExpression.ToString()); // This code produces the following output: // // (53 - 14) // </Snippet8> }
static Arithmetics() { MINUS_ONE = (T)System.Convert.ChangeType(-1, typeof(T)); ZERO = (T)System.Convert.ChangeType(0, typeof(T)); ONE = (T)System.Convert.ChangeType(1, typeof(T)); TWO = (T)System.Convert.ChangeType(2, typeof(T)); THREE = (T)System.Convert.ChangeType(3, typeof(T)); DecimalEpsilon = new decimal(1, 0, 0, false, 27); DecimalPositiveInfinity = 1m / DecimalEpsilon; DecimalNegativeInfinity = -1m / DecimalEpsilon; System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Add the parameters together System.Linq.Expressions.BinaryExpression addBody = System.Linq.Expressions.Expression.Add(paramA, paramB); // a-b System.Linq.Expressions.BinaryExpression subtractBody = System.Linq.Expressions.Expression.Subtract(paramA, paramB); // a*b System.Linq.Expressions.BinaryExpression multiplyBody = System.Linq.Expressions.Expression.Multiply(paramA, paramB); // a/b System.Linq.Expressions.BinaryExpression divideBody = System.Linq.Expressions.Expression.Divide(paramA, paramB); // a%b System.Linq.Expressions.BinaryExpression moduloBody = System.Linq.Expressions.Expression.Modulo(paramA, paramB); Add = System.Linq.Expressions.Expression.Lambda <Operation_T>(addBody, paramA, paramB).Compile(); Subtract = System.Linq.Expressions.Expression.Lambda <Operation_T>(subtractBody, paramA, paramB).Compile(); MultiplyInternal = System.Linq.Expressions.Expression.Lambda <Operation_T>(multiplyBody, paramA, paramB).Compile(); Divide = System.Linq.Expressions.Expression.Lambda <Operation_T>(divideBody, paramA, paramB).Compile(); Mod = System.Linq.Expressions.Expression.Lambda <Operation_T>(moduloBody, paramA, paramB).Compile(); }
protected override System.Linq.Expressions.Expression VisitBinary(System.Linq.Expressions.BinaryExpression b) { this.Visit(b.Left); if (this.ExcuteType == DMSExcuteType.SELECT || this.ExcuteType == DMSExcuteType.UPDATE || this.ExcuteType == DMSExcuteType.UPDATE_WHERE) { this._LastestOperator = new System.Linq.Expressions.ExpressionType?(b.NodeType); this._strSql.Append(" " + DMSOperators.FormatBinaryOperator(this._LastestOperator) + " "); } else if (this.ExcuteType == DMSExcuteType.INSERT_SELECT) { this._LastestOperator = new System.Linq.Expressions.ExpressionType?(b.NodeType); this._ParamSql.Append(" " + DMSOperators.FormatBinaryOperator(this._LastestOperator) + " "); } this.Visit(b.Right); return(b); }
/// <summary> /// 右边表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> object RightExpressionRouter(System.Linq.Expressions.Expression exp) { string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression) { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else { return(System.Linq.Expressions.Expression.Lambda(exp).Compile().DynamicInvoke()); } }
/// <summary>Visits a binary expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitBinary(System.Linq.Expressions.BinaryExpression expression) { MethodNames operatorName; System.Linq.Expressions.ExpressionType expressionType = expression.NodeType; switch (expression.NodeType) { case System.Linq.Expressions.ExpressionType.OrElse: expressionType = System.Linq.Expressions.ExpressionType.Or; goto default; case System.Linq.Expressions.ExpressionType.AndAlso: expressionType = System.Linq.Expressions.ExpressionType.And; goto default; default: string methodName = Enum.GetNames(typeof(MethodNames)).Where(item => item == expressionType.ToString()).FirstOrDefault(); if (!System.String.IsNullOrEmpty(methodName)) { operatorName = (MethodNames)Enum.Parse(typeof(MethodNames), methodName); } else { return(base.VisitBinary(expression)); } break; } BinaryOperator binaryOperator = new BinaryOperator(operatorName); HandleComponent(binaryOperator); Visit(expression.Left); CleanupComponent(_lastComponent); Visit(expression.Right); CleanupComponent(_lastComponent); _lastComponent = binaryOperator; return(expression); }