public static ExpressionFingerprint Create(Expression expression, ParserContext context) { BinaryExpression binaryExpression = (expression as BinaryExpression); if (binaryExpression != null) return BinaryExpressionFingerprint.Create(binaryExpression, context); ConditionalExpression conditionalExpression = (expression as ConditionalExpression); if (conditionalExpression != null) return ConditionalExpressionFingerprint.Create(conditionalExpression, context); ConstantExpression constantExpression = (expression as ConstantExpression); if (constantExpression != null) return ConstantExpressionFingerprint.Create(constantExpression, context); MemberExpression memberExpression = (expression as MemberExpression); if (memberExpression != null) return MemberExpressionFingerprint.Create(memberExpression, context); MethodCallExpression methodCallExpression = (expression as MethodCallExpression); if (methodCallExpression != null) return MethodCallExpressionFingerprint.Create(methodCallExpression, context); ParameterExpression parameterExpression = (expression as ParameterExpression); if (parameterExpression != null) return ParameterExpressionFingerprint.Create(parameterExpression, context); UnaryExpression unaryExpression = (expression as UnaryExpression); if (unaryExpression != null) return UnaryExpressionFingerprint.Create(unaryExpression, context); return null; }
public override Expression ToExpression(ParserContext context) { BinaryExpression index = Expression.ArrayIndex( ParserContext.HoistedValuesParameter, Expression.Constant(_index)); return Expression.Convert(index, Type); }
public static ParameterExpressionFingerprint Create( ParameterExpression expression, ParserContext context) { if (expression == context.Instance) return new ParameterExpressionFingerprint(expression); else return null; }
public override Expression ToExpression(ParserContext context) { Expression operand = ToExpression(_operand, context); if (NodeType == ExpressionType.UnaryPlus) return Expression.UnaryPlus(operand, Method); return Expression.MakeUnary(NodeType, operand, Type, _method); }
public static UnaryExpressionFingerprint Create( UnaryExpression expression, ParserContext context) { ExpressionFingerprint operand = Create(expression.Operand, context); if (operand == null && expression.Operand != null) return null; return new UnaryExpressionFingerprint(expression) { _operand = operand }; }
public static MemberExpressionFingerprint Create( MemberExpression expression, ParserContext context) { ExpressionFingerprint target = Create(expression.Expression, context); if (target == null && expression.Expression != null) return null; return new MemberExpressionFingerprint(expression) { _target = target }; }
public static ConstantExpressionFingerprint Create( ConstantExpression expression, ParserContext context) { ConstantExpressionFingerprint fingerprint = new ConstantExpressionFingerprint(expression) { _index = context.HoistedValues.Count }; context.HoistedValues.Add(expression.Value); return fingerprint; }
public static MethodCallExpressionFingerprint Create( MethodCallExpression expression, ParserContext context) { ReadOnlyCollection<ExpressionFingerprint> arguments = Create(expression.Arguments, context); if (arguments == null) return null; ExpressionFingerprint target = Create(expression.Object, context); if (target == null && expression.Object != null) return null; return new MethodCallExpressionFingerprint(expression) { _arguments = arguments, _target = target }; }
public static BinaryExpressionFingerprint Create( BinaryExpression expression, ParserContext context) { if (expression.Conversion != null) return null; ExpressionFingerprint left = Create(expression.Left, context); if (left == null && expression.Left != null) return null; ExpressionFingerprint right = Create(expression.Right, context); if (right == null && expression.Right != null) return null; return new BinaryExpressionFingerprint(expression) { _left = left, _right = right }; }
public static ConditionalExpressionFingerprint Create( ConditionalExpression expression, ParserContext context) { ExpressionFingerprint test = Create(expression.Test, context); if (test == null && expression.Test != null) return null; ExpressionFingerprint ifTrue = Create(expression.IfTrue, context); if (ifTrue == null && expression.IfTrue != null) return null; ExpressionFingerprint ifFalse = Create(expression.IfFalse, context); if (ifFalse == null && expression.IfFalse != null) return null; return new ConditionalExpressionFingerprint(expression) { _test = test, _ifTrue = ifTrue, _ifFalse = ifFalse }; }
public override Expression ToExpression(ParserContext context) { return context.Instance; }
public override Expression ToExpression(ParserContext context) { Expression target = ToExpression(_target, context); IEnumerable<Expression> arguments = ToExpression(_arguments, context); return Expression.Call(target, _method, arguments); }
public abstract Expression ToExpression(ParserContext context);
protected static IEnumerable<Expression> ToExpression( IEnumerable<ExpressionFingerprint> fingerprints, ParserContext context) { return fingerprints.Select(f => ToExpression(f, context)); }
protected static Expression ToExpression(ExpressionFingerprint fingerprint, ParserContext context) { return (fingerprint == null) ? null : fingerprint.ToExpression(context); }
public static ReadOnlyCollection<ExpressionFingerprint> Create( IEnumerable<Expression> expressions, ParserContext context) { List<ExpressionFingerprint> fingerprints = new List<ExpressionFingerprint>(); foreach (Expression expression in expressions) { ExpressionFingerprint fingerprint = Create(expression, context); if (fingerprint == null && expression != null) return null; fingerprints.Add(fingerprint); } return new ReadOnlyCollection<ExpressionFingerprint>(fingerprints); }
public override Expression ToExpression(ParserContext context) { Expression test = ToExpression(_test, context); Expression ifTrue = ToExpression(_ifTrue, context); Expression ifFalse = ToExpression(_ifFalse, context); return Expression.Condition(test, ifTrue, ifFalse); }
public override Expression ToExpression(ParserContext context) { return Expression.MakeMemberAccess( ToExpression(_target, context), _member); }
public override Expression ToExpression(ParserContext context) { Expression left = ToExpression(_left, context); Expression right = ToExpression(_right, context); return Expression.MakeBinary(NodeType, left, right, _isLiftedToNull, _method); }
public override Expression ToExpression(ParserContext context) { return(context.Instance); }