private static LambdaExpression PartialApplyLambda <TParam2>(LambdaExpression expression, TParam2 paramValue)
{
ParameterExpression parameterExpression = Enumerable.Last <ParameterExpression>((IEnumerable <ParameterExpression>)expression.Parameters);
ConstantExpression constantExpression = Expression.Constant((object)paramValue, parameterExpression.Type);
return(Expression.Lambda(ExpressionExtensions.Replace <Expression>(expression.Body, (Expression)parameterExpression, (Expression)constantExpression), Enumerable.Take <ParameterExpression>((IEnumerable <ParameterExpression>)expression.Parameters, expression.Parameters.Count - 1)));
}
public static Expression <Func <T, TResult> > MakeSingleParameter <T, TResult>(this Expression <Func <T, T, TResult> > selector)
{
ParameterExpression what = selector.Parameters[1];
ParameterExpression parameterExpression = selector.Parameters[0];
return(Expression.Lambda <Func <T, TResult> >(ExpressionExtensions.Replace <Expression>(selector.Body, (Func <Expression, bool>)(x => x == what), (Expression)parameterExpression), new ParameterExpression[1]
{
parameterExpression
}));
}
public static Expression <Func <TNewParam, TResult> > ReplaceLambdaParameter <TNewParam, TResult>(this LambdaExpression e, LambdaExpression replacement)
{
ParameterExpression oldParameter = e.Parameters[0];
ParameterExpression parameterExpression = replacement.Parameters[0];
return((Expression <Func <TNewParam, TResult> >)Expression.Lambda(ExpressionExtensions.Replace <Expression>(e.Body, (Func <Expression, bool>)(x => x == oldParameter), replacement.Body), new ParameterExpression[1]
{
parameterExpression
}));
}
internal static Expression Apply(this LambdaExpression lambda, IEnumerable <Expression> arguments)
{
arguments = (IEnumerable <Expression>)Enumerable.ToList <Expression>(arguments);
if (Enumerable.Count <ParameterExpression>((IEnumerable <ParameterExpression>)lambda.Parameters) == Enumerable.Count <Expression>(arguments))
{
return(Enumerable.Aggregate(Enumerable.Zip((IEnumerable <ParameterExpression>)lambda.Parameters, arguments, (parameter, argument) =>
{
var local_0 = new
{
parameter = parameter,
argument = argument
};
return local_0;
}), lambda.Body, (body, pair) => ExpressionExtensions.Replace <Expression>(body, (Func <Expression, bool>)(x => x == pair.parameter), pair.argument)));
}
throw new ArgumentException(StringExtensions.Fmt("Expected {0} parameters, given {1} arguments", (object)Enumerable.Count <ParameterExpression>((IEnumerable <ParameterExpression>)lambda.Parameters), (object)Enumerable.Count <Expression>(arguments)));
}
public static Expression <Func <T, TResult> > Convert <T, TResult>(this LambdaExpression e)
{
bool flag1 = e.Body.Type != typeof(TResult);
ParameterExpression oldParameter = e.Parameters[0];
bool flag2 = oldParameter.Type != typeof(T);
LambdaExpression lambdaExpression = flag1 ? Expression.Lambda((Expression)Expression.Convert(e.Body, typeof(TResult)), (IEnumerable <ParameterExpression>)e.Parameters) : e;
if (flag2)
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(T), oldParameter.Name);
lambdaExpression = Expression.Lambda(ExpressionExtensions.Replace <Expression>(lambdaExpression.Body, (Func <Expression, bool>)(x => x == oldParameter), (Expression)Expression.Convert((Expression)parameterExpression, oldParameter.Type)), new ParameterExpression[1]
{
parameterExpression
});
}
return((Expression <Func <T, TResult> >)lambdaExpression);
}
public static Expression ApplyExpression(this LambdaExpression lambda, params Expression[] arguments)
{
return(ExpressionExtensions.Apply(lambda, Enumerable.AsEnumerable <Expression>((IEnumerable <Expression>)arguments)));
}
public static Expression <Func <T, bool> > CombineOr <T>(this Expression <Func <T, bool> > head, params Expression <Func <T, bool> >[] tail)
{
return(ExpressionExtensions.Combine <T>(head, (IEnumerable <Expression <Func <T, bool> > >)tail, new Func <Expression, Expression, BinaryExpression>(Expression.OrElse)));
}
public static bool IsConstantNull(this Expression e)
{
return(ExpressionExtensions.IsConstant(e, (object)null));
}
public static Expression <Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> > PartialApply <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(this Expression <Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> > expression, T15 paramValue)
{
return((Expression <Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> >)ExpressionExtensions.PartialApplyLambda <T15>((LambdaExpression)expression, paramValue));
}
public static Expression <Func <T1, T2, T3, TResult> > PartialApply <T1, T2, T3, T4, TResult>(this Expression <Func <T1, T2, T3, T4, TResult> > expression, T4 paramValue)
{
return((Expression <Func <T1, T2, T3, TResult> >)ExpressionExtensions.PartialApplyLambda <T4>((LambdaExpression)expression, paramValue));
}
