public static ConstantExpressionFingerprint Create(ConstantExpression expression, ParserContext parserContext) {
ConstantExpressionFingerprint fingerprint = new ConstantExpressionFingerprint(expression) {
HoistedLocalsIndex = parserContext.HoistedValues.Count
};
parserContext.HoistedValues.Add(expression.Value);
return fingerprint;
}
public static ParameterExpressionFingerprint Create(ParameterExpression expression, ParserContext parserContext) {
if (expression == parserContext.ModelParameter) {
return new ParameterExpressionFingerprint(expression);
}
else {
// degenerate case - uncaptured parameter expression passed into the system
return null;
}
}
public static MemberExpressionFingerprint Create(MemberExpression expression, ParserContext parserContext) {
ExpressionFingerprint target = Create(expression.Expression, parserContext);
if (target == null && expression.Expression != null) {
return null;
}
return new MemberExpressionFingerprint(expression) {
Target = target
};
}
public static ExpressionFingerprint Create(Expression expression, ParserContext parserContext)
{
{
BinaryExpression binaryExpression = expression as BinaryExpression;
if (binaryExpression != null) {
return BinaryExpressionFingerprint.Create(binaryExpression, parserContext);
}
}
{
ConditionalExpression conditionalExpression = expression as ConditionalExpression;
if (conditionalExpression != null) {
return ConditionalExpressionFingerprint.Create(conditionalExpression, parserContext);
}
}
{
ConstantExpression constantExpression = expression as ConstantExpression;
if (constantExpression != null) {
return ConstantExpressionFingerprint.Create(constantExpression, parserContext);
}
}
{
MemberExpression memberExpression = expression as MemberExpression;
if (memberExpression != null) {
return MemberExpressionFingerprint.Create(memberExpression, parserContext);
}
}
{
MethodCallExpression methodCallExpression = expression as MethodCallExpression;
if (methodCallExpression != null) {
return MethodCallExpressionFingerprint.Create(methodCallExpression, parserContext);
}
}
{
ParameterExpression parameterExpression = expression as ParameterExpression;
if (parameterExpression != null) {
return ParameterExpressionFingerprint.Create(parameterExpression, parserContext);
}
}
{
UnaryExpression unaryExpression = expression as UnaryExpression;
if (unaryExpression != null) {
return UnaryExpressionFingerprint.Create(unaryExpression, parserContext);
}
}
// unknown expression
return null;
}
public override Expression ToExpression(ParserContext parserContext) {
Expression operandExpr = ToExpression(Operand, parserContext);
// in .NET 3.5 SP1, Expression.MakeUnary() throws if NodeType is UnaryPlus, so special-case
if (NodeType == ExpressionType.UnaryPlus) {
return Expression.UnaryPlus(operandExpr, Method);
}
else {
return Expression.MakeUnary(NodeType, operandExpr, Type, Method);
}
}
public static UnaryExpressionFingerprint Create(UnaryExpression expression, ParserContext parserContext) {
ExpressionFingerprint operand = Create(expression.Operand, parserContext);
if (operand == null && expression.Operand != null) {
// couldn't convert the operand, so bail
return null;
}
return new UnaryExpressionFingerprint(expression) {
Operand = operand
};
}
public static MethodCallExpressionFingerprint Create(MethodCallExpression expression, ParserContext parserContext) {
ReadOnlyCollection<ExpressionFingerprint> arguments = Create(expression.Arguments, parserContext);
if (arguments == null) {
return null;
}
ExpressionFingerprint target = Create(expression.Object, parserContext);
if (target == null && expression.Object != null) {
return null;
}
return new MethodCallExpressionFingerprint(expression) {
Arguments = arguments,
Target = target
};
}
public static BinaryExpressionFingerprint Create(BinaryExpression expression, ParserContext parserContext) {
if (expression.Conversion != null) {
// we don't support the Conversion property
return null;
}
// if any fingerprinting fails, bail out
ExpressionFingerprint left = Create(expression.Left, parserContext);
if (left == null && expression.Left != null) {
return null;
}
ExpressionFingerprint right = Create(expression.Right, parserContext);
if (right == null && expression.Right != null) {
return null;
}
return new BinaryExpressionFingerprint(expression) {
Left = left,
Right = right
};
}
public static ConditionalExpressionFingerprint Create(ConditionalExpression expression, ParserContext parserContext) {
// if any fingerprinting fails, bail out
ExpressionFingerprint test = Create(expression.Test, parserContext);
if (test == null && expression.Test != null) {
return null;
}
ExpressionFingerprint ifTrue = Create(expression.IfTrue, parserContext);
if (ifTrue == null && expression.IfTrue != null) {
return null;
}
ExpressionFingerprint ifFalse = Create(expression.IfFalse, parserContext);
if (ifFalse == null && expression.IfFalse != null) {
return null;
}
return new ConditionalExpressionFingerprint(expression) {
Test = test,
IfTrue = ifTrue,
IfFalse = ifFalse
};
}
public static BinaryExpressionFingerprint Create(BinaryExpression expression, ParserContext parserContext)
{
if (expression.Conversion != null)
{
// we don't support the Conversion property
return(null);
}
// if any fingerprinting fails, bail out
ExpressionFingerprint left = Create(expression.Left, parserContext);
if (left == null && expression.Left != null)
{
return(null);
}
ExpressionFingerprint right = Create(expression.Right, parserContext);
if (right == null && expression.Right != null)
{
return(null);
}
return(new BinaryExpressionFingerprint(expression)
{
Left = left,
Right = right
});
}
public override Expression ToExpression(ParserContext parserContext) {
Expression targetExpr = ToExpression(Target, parserContext);
return Expression.MakeMemberAccess(targetExpr, Member);
}
public override Expression ToExpression(ParserContext parserContext) {
Expression leftExpr = ToExpression(Left, parserContext);
Expression rightExpr = ToExpression(Right, parserContext);
return Expression.MakeBinary(NodeType, leftExpr, rightExpr, IsLiftedToNull, Method);
}
public CompiledExpressionDelegate <TModel, TValue> GetDelegate(ParserContext context)
{
return(FetchOrCreateItem(context.Fingerprint, () => CreateDelegate(context)));
}
public override Expression ToExpression(ParserContext parserContext) {
// (Type) HoistedValues[HoistedLocalsIndex]
BinaryExpression arrayIndex = Expression.ArrayIndex(ParserContext.HoistedValuesParameter, Expression.Constant(HoistedLocalsIndex));
UnaryExpression castExpr = Expression.Convert(arrayIndex, Type);
return castExpr;
}
public override Expression ToExpression(ParserContext parserContext)
{
// The only time an instance of this class exists is if it represents the actual model parameter,
// so just return it directly.
return parserContext.ModelParameter;
}
public override Expression ToExpression(ParserContext parserContext) {
Expression targetExpr = ToExpression(Target, parserContext);
IEnumerable<Expression> argumentsExpr = ToExpression(Arguments, parserContext);
return Expression.Call(targetExpr, Method, argumentsExpr);
}
private static CompiledExpressionDelegate <TModel, TValue> CreateDelegate(ParserContext context)
{
var bodyExpr = context.Fingerprint.ToExpression(context);
var lambdaExpr = Expression.Lambda <CompiledExpressionDelegate <TModel, TValue> >(bodyExpr, context.ModelParameter, ParserContext.HoistedValuesParameter);
var del = lambdaExpr.Compile();
return(del);
}
public static ReadOnlyCollection<ExpressionFingerprint> Create(IEnumerable<Expression> expressions, ParserContext parserContext)
{
List<ExpressionFingerprint> fingerprints = new List<ExpressionFingerprint>();
foreach (Expression expression in expressions) {
ExpressionFingerprint fingerprint = Create(expression, parserContext);
if (fingerprint == null && expression != null) {
// something couldn't be parsed properly
return null;
}
else {
fingerprints.Add(fingerprint);
}
}
return new ReadOnlyCollection<ExpressionFingerprint>(fingerprints);
}
public static ConditionalExpressionFingerprint Create(ConditionalExpression expression, ParserContext parserContext)
{
// if any fingerprinting fails, bail out
ExpressionFingerprint test = Create(expression.Test, parserContext);
if (test == null && expression.Test != null)
{
return(null);
}
ExpressionFingerprint ifTrue = Create(expression.IfTrue, parserContext);
if (ifTrue == null && expression.IfTrue != null)
{
return(null);
}
ExpressionFingerprint ifFalse = Create(expression.IfFalse, parserContext);
if (ifFalse == null && expression.IfFalse != null)
{
return(null);
}
return(new ConditionalExpressionFingerprint(expression)
{
Test = test,
IfTrue = ifTrue,
IfFalse = ifFalse
});
}
protected static IEnumerable<Expression> ToExpression(IEnumerable<ExpressionFingerprint> fingerprints, ParserContext parserContext)
{
return from fingerprint in fingerprints select ToExpression(fingerprint, parserContext);
}
protected static Expression ToExpression(ExpressionFingerprint fingerprint, ParserContext parserContext)
{
return (fingerprint != null) ? fingerprint.ToExpression(parserContext) : null;
}
public abstract Expression ToExpression(ParserContext parserContext);
public static MethodCallExpressionFingerprint Create(MethodCallExpression expression, ParserContext parserContext)
{
ReadOnlyCollection <ExpressionFingerprint> arguments = Create(expression.Arguments, parserContext);
if (arguments == null)
{
return(null);
}
ExpressionFingerprint target = Create(expression.Object, parserContext);
if (target == null && expression.Object != null)
{
return(null);
}
return(new MethodCallExpressionFingerprint(expression)
{
Arguments = arguments,
Target = target
});
}
public override Expression ToExpression(ParserContext parserContext) {
Expression testExpr = ToExpression(Test, parserContext);
Expression ifTrueExpr = ToExpression(IfTrue, parserContext);
Expression ifFalseExpr = ToExpression(IfFalse, parserContext);
return Expression.Condition(testExpr, ifTrueExpr, ifFalseExpr);
}