private static ExpressionInfo <Func <int, int, int> > CreateSumExprInfo()
{
var aExp = ExpressionInfo.Parameter(typeof(int), "a");
var bExp = ExpressionInfo.Parameter(typeof(int), "b");
return(ExpressionInfo.Lambda <Func <int, int, int> >(
ExpressionInfo.Add(aExp, bExp), aExp, bExp));
}
// ReSharper disable once SuggestBaseTypeForParameter
/// <code>
/// context{i} => behavior.Invoke(context{i}, context{i+1} => previous)
/// </code>>
static Delegate CreateBehaviorCallDelegate(IBehavior currentBehavior, MethodInfo methodInfo, ParameterExpression outerContextParam, Delegate previous, List <Expression> expressions = null)
{
var body = ExpressionInfo.Call(ExpressionInfo.Constant(currentBehavior), methodInfo, outerContextParam, ExpressionInfo.Constant(previous));
var lambdaExpression = ExpressionInfo.Lambda(body, outerContextParam);
expressions?.Add(lambdaExpression.ToExpression());
return(lambdaExpression.CompileFast());
}
public void Can_embed_normal_Expression_into_ExpressionInfo_eg_as_Constructor_argument()
{
var func = ExpressionCompiler.TryCompile <Func <P> >(
ExpressionInfo.Lambda(
ExpressionInfo.New(_ctorOfP,
Expression.New(_ctorOfB))));
Assert.IsInstanceOf <P>(func());
}
public void Can_sum_with_ExprInfo()
{
var a = ExpressionInfo.Parameter(typeof(int), "a");
var b = ExpressionInfo.Parameter(typeof(int), "b");
var expr = ExpressionInfo.Lambda <Func <int, int, int> >(ExpressionInfo.Add(a, b), a, b);
var sumFunc = expr.CompileFast(true);
Assert.IsNotNull(sumFunc);
Assert.AreEqual(sumFunc(1, 3), 4);
}
public void Can_assign_to_parameter_via_ExpressionInfo()
{
var sParamExpr = Parameter(typeof(string), "s");
var expr = ExpressionInfo.Lambda <Func <string, string> >(
ExpressionInfo.Assign(sParamExpr, ExpressionInfo.Constant("aaa")),
sParamExpr);
var f = expr.TryCompile();
Assert.IsNotNull(f);
Assert.AreEqual("aaa", f("ignored"));
}
public object CreateExpressionInfo_and_FastCompile()
{
//Expression<Func<Action<string>>> expr = () => a => s.SetValue(a);
var aParam = Expression.Parameter(typeof(string), "a");
var expr = ExpressionInfo.Lambda(
ExpressionInfo.Lambda(
ExpressionInfo.Call(ExpressionInfo.Constant(_s), _setValueMethod, aParam),
aParam
)
);
return(expr.TryCompile <Func <Action <string> > >());
}
public void Nested_Func_using_outer_parameter()
{
// The same hoisted expression:
//Expression<Func<string, string>> expr = a => GetS(() => a);
var aParam = Expression.Parameter(typeof(string), "a");
var expr = ExpressionInfo.Lambda(
ExpressionInfo.Call(GetType().GetTypeInfo().DeclaredMethods.First(m => m.Name == nameof(GetS)),
ExpressionInfo.Lambda(aParam)),
aParam);
var f = ExpressionCompiler.TryCompile <Func <string, string> >(expr);
Assert.AreEqual("a", f("a"));
}
public void Can_compile_lambda_with_property()
{
var thisType = GetType().GetTypeInfo();
var funcExpr =
ExpressionInfo.Lambda(
ExpressionInfo.Property(thisType.GetProperty(nameof(PropX))));
var func = ExpressionCompiler.TryCompile <Func <X> >(funcExpr);
Assert.IsNotNull(func);
var x = func();
Assert.IsInstanceOf <X>(x);
}
public void Can_compile_lambda_without_coverting_to_expression()
{
var funcExpr =
ExpressionInfo.Lambda(
ExpressionInfo.New(typeof(X).GetTypeInfo().GetConstructors()[0],
ExpressionInfo.New(typeof(Y).GetTypeInfo().GetConstructors()[0])));
var func = ExpressionCompiler.TryCompile <Func <X> >(funcExpr);
Assert.IsNotNull(func);
var x = func();
Assert.IsInstanceOf <X>(x);
}
public void Given_composed_exprInfo_with_closure_over_parameters_in_nested_lambda_should_work()
{
var argExpr = Expression.Parameter(typeof(object));
var funcExpr = ExpressionInfo.Lambda(
ExpressionInfo.Invoke(ExpressionInfo.Lambda(
ExpressionInfo.Invoke(ExpressionInfo.Lambda(argExpr)))),
argExpr);
var funcFec = funcExpr.TryCompile <Func <object, object> >();
var arg1 = new object();
Assert.AreSame(arg1, funcFec(arg1));
var arg2 = new object();
Assert.AreSame(arg2, funcFec(arg2));
Assert.AreSame(arg1, funcFec(arg1));
}
public void Nested_Action_using_outer_parameter_and_closed_value()
{
var s = new S();
//Expression<Func<Action<string>>> expr = () => a => s.SetValue(a);
var aParam = Expression.Parameter(typeof(string), "a");
var expr = ExpressionInfo.Lambda(
ExpressionInfo.Lambda(
ExpressionInfo.Call(
ExpressionInfo.Constant(s),
typeof(S).GetTypeInfo().DeclaredMethods.First(m => m.Name == nameof(S.SetValue)),
aParam),
aParam)
);
var f = ExpressionCompiler.TryCompile <Func <Action <string> > >(expr);
f()("a");
Assert.AreEqual("a", s.Value);
}
public static ExpressionInfo <Func <object[], object> > CreateComplexExpressionInfo()
{
var stateParamExpr = Expression.Parameter(typeof(object[]));
var expr = ExpressionInfo.Lambda <Func <object[], object> >(
ExpressionInfo.MemberInit(
ExpressionInfo.New(_ctorOfA,
ExpressionInfo.New(_ctorOfB),
ExpressionInfo.Convert(
ExpressionInfo.ArrayIndex(stateParamExpr, ExpressionInfo.Constant(11)),
typeof(string)),
ExpressionInfo.NewArrayInit(typeof(ID[]),
ExpressionInfo.New(_ctorOfD1),
ExpressionInfo.New(_ctorOfD2))),
ExpressionInfo.Bind(_propAProp,
ExpressionInfo.New(_ctorOfP,
ExpressionInfo.New(_ctorOfB))),
ExpressionInfo.Bind(_fieldABop,
ExpressionInfo.New(_ctorOfB))),
stateParamExpr);
return(expr);
}
/// <code>
/// context{i} => return TaskEx.CompletedTask;
/// </code>>
static Delegate CreateDoneDelegate(Type inContextType, int i)
{
var innerContextParam = ExpressionInfo.Parameter(inContextType, $"context{i + 1}");
return(ExpressionInfo.Lambda(ExpressionInfo.Constant(Task.CompletedTask), innerContextParam).CompileFast());
}
public object CreateExpressionInfo_and_FastCompile()
{
var expr = ExpressionInfo.Lambda(ExpressionInfo.New(_xCtor, ExpressionInfo.New(_aCtor), ExpressionInfo.New(_bCtor)));
return(expr.TryCompile <Func <object> >());
}
