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