public void Can_compile_complex_expr_with_Array_Properties_and_Casts()
{
var expr = CreateComplexExpressionInfo();
var func = ExpressionCompiler.TryCompile(expr);
func(new object[12]);
}
public void Given_composed_expr_with_closure_over_parameters_used_in_2_levels_of_nested_lambda()
{
//Func<A, A> funcEthalon = a => a.Increment(() => a.Increment(() => a.Increment(null)));
var aExpr = Expression.Parameter(typeof(A));
var funcExpr = Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
Expression.Constant(null, typeof(Func <A>))
)
)
)
)
),
aExpr);
var func = ExpressionCompiler.TryCompile <Func <A, A> >(funcExpr);
var a1 = new A();
var result1 = func(a1);
Assert.AreEqual(3, result1.X);
Assert.AreSame(a1, result1);
var a2 = new A();
Assert.AreSame(a2, func(a2));
}
public void Nested_lambda_using_outer_parameter_and_closed_value_deeply_nested_lambda()
{
var b = new S {
Value = "b"
};
// The same hoisted expression:
//Expression<Func<string, string>> expr =
// a => GetS(
// () => b.Prepend(a,
// rest => b.Append(rest)));
var bExpr = Expression.Constant(b);
var aParam = Expression.Parameter(typeof(string), "a");
var bbParam = Expression.Parameter(typeof(string), "bb");
var expr = Expression.Lambda(
Expression.Call(GetType(), nameof(GetS), Type.EmptyTypes,
Expression.Lambda(
Expression.Call(bExpr, "Prepend", Type.EmptyTypes,
aParam,
Expression.Lambda(Expression.Call(bExpr, "Append", Type.EmptyTypes, bbParam),
bbParam)))),
aParam);
var f = ExpressionCompiler.TryCompile <Func <string, string> >(expr);
Assert.AreEqual("abb", f("a"));
}
public void Nested_Hoisted_Func_using_outer_parameter()
{
Expression <Func <string, string> > expr = a => GetS(() => a);
var f = ExpressionCompiler.TryCompile <Func <string, string> >(expr);
Assert.AreEqual("a", f("a"));
}
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_use_constant_of_byte_Enum_type()
{
object obj = XByte.A;
var e = Expression.Lambda(Expression.Constant(obj));
var f = ExpressionCompiler.TryCompile <Func <XByte> >(e);
Assert.AreEqual(XByte.A, f());
}
public void Logical_and_with_or()
{
var x = 1;
var s = "Test";
Expression <Func <bool> > expr = () => x == 1 && (s.Contains("S") || s.Contains("s"));
var dele = ExpressionCompiler.TryCompile <Func <bool> >(expr);
Assert.IsNotNull(dele);
}
public void Logical_and()
{
var x = 1;
var s = "Test";
Expression <Func <bool> > expr = () => x == 1 && s.Contains("S");
var dlg = ExpressionCompiler.TryCompile <Func <bool> >(expr);
Assert.IsNotNull(dlg);
Assert.IsFalse(dlg());
}
public void Ternarary_operator_with_less_then()
{
var x = 1;
var s = "Test";
Expression <Func <object> > expr = () => x < 1 ? string.Concat(s, "ccc") : string.Empty;
var dlg = ExpressionCompiler.TryCompile <Func <object> >(expr);
Assert.IsNotNull(dlg);
Assert.AreEqual(string.Empty, dlg());
}
public void Nested_Hoisted_Action_using_outer_parameter_and_closed_value()
{
// The same hoisted expression:
var s = new S();
Expression <Func <Action <string> > > expr = () => a => s.SetValue(a);
var f = ExpressionCompiler.TryCompile <Func <Action <string> > >(expr);
f()("a");
Assert.AreEqual("a", s.Value);
}
public void Ternarary_operator_with_equality()
{
var x = 1;
var s = "Test";
Expression <Func <object> > expr = () => x == 1 ? s : string.Empty;
var dlg = ExpressionCompiler.TryCompile <Func <object> >(expr);
Assert.IsNotNull(dlg);
Assert.AreEqual(s, dlg());
}
public void Nested_Hoisted_Func_using_outer_parameter_and_closed_value()
{
var b = new S {
Value = "b"
};
Expression <Func <string, string> > expr = a => GetS(() => b.Append(a));
var f = ExpressionCompiler.TryCompile <Func <string, string> >(expr);
Assert.AreEqual("ba", f("a"));
}
public void Logical_and_or_and()
{
var f = false;
var t = true;
var x = 1;
var s = "Test";
Expression <Func <bool> > expr = () =>
(f || x == 1) && (s.Contains("S") || s.Contains("s")) || t;
var dlg = ExpressionCompiler.TryCompile <Func <bool> >(expr);
Assert.IsNotNull(dlg);
Assert.IsTrue(dlg());
}
public void Can_assign_Readonly_member_of_existing_object()
{
var a = new A();
var aConstExpr = Constant(a);
var expr = Lambda <Func <A> >(
MemberInit(
aConstExpr,
Bind(typeof(A).GetTypeInfo().DeclaredFields.First(m => m.Name == "R"),
Constant(24))));
var f = ExpressionCompiler.TryCompile(expr);
Assert.AreEqual(24, f().R);
}
public void Nested_Hoisted_lambda_using_outer_parameter_and_closed_value_deeply_nested_lambda()
{
var b = new S {
Value = "b"
};
Expression <Func <string, string> > expr =
a => GetS(
() => b.Prepend(a,
rest => b.Append(rest)));
var f = ExpressionCompiler.TryCompile <Func <string, string> >(expr);
Assert.AreEqual("abb", f("a"));
}
public void Nested_lambda_using_outer_parameter()
{
// The same hoisted expression:
//Expression<Func<string, string>> expr = a => GetS(() => a);
var aParam = Expression.Parameter(typeof(string), "a");
var expr = Expression.Lambda(
Expression.Call(GetType(), nameof(GetS), Type.EmptyTypes,
Expression.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 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 Ternarary_operator_with_logical_op()
{
var x = 1;
var s = "Test";
Expression <Func <object> > expr = () =>
x > 0 &&
(s.Contains("e") && s.Contains("X") ||
s.StartsWith("T") && s.EndsWith("t"))
? string.Concat(s, "ccc")
: string.Empty;
var dlg = ExpressionCompiler.TryCompile <Func <object> >(expr);
Assert.IsNotNull(dlg);
Assert.AreEqual(string.Concat(s, "ccc"), dlg());
}
public void Given_composed_expr_with_closure_over_2_parameters_used_in_2_levels_of_nested_lambda()
{
Func <A, A, A> funcEthalon = (a, b) => a.Increment(b, () => a.Increment(b, () => a.Increment(b, null)));
var aa = new A();
var bb = new A();
funcEthalon(aa, bb);
Assert.AreEqual(3, aa.X);
Assert.AreEqual(-3, bb.X);
var aExpr = Expression.Parameter(typeof(A), "a");
var bExpr = Expression.Parameter(typeof(A), "b");
var funcExpr = Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
bExpr,
Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
bExpr,
Expression.Lambda(
Expression.Call(aExpr, "Increment", new Type[0],
bExpr,
Expression.Constant(null, typeof(Func <A>))
)
)
)
)
),
aExpr, bExpr);
var func = ExpressionCompiler.TryCompile <Func <A, A, A> >(funcExpr);
var a1 = new A();
var b1 = new A();
var result1 = func(a1, b1);
Assert.AreEqual(3, result1.X);
Assert.AreSame(a1, result1);
var a2 = new A();
var b2 = new A();
Assert.AreSame(a2, func(a2, b2));
}
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 void Given_composed_expr_with_closure_over_parameters_in_nested_lambda_should_work()
{
var argExpr = Expression.Parameter(typeof(object));
var funcExpr = Expression.Lambda(
Expression.Invoke(Expression.Lambda(
Expression.Invoke(Expression.Lambda(argExpr)))),
argExpr);
var funcFec = ExpressionCompiler.TryCompile <Func <object, object> >(funcExpr);
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 Given_hoisted_expr_with_closure_over_parameters_in_nested_lambda_should_work()
{
Expression <Func <object, object> > funcExpr = a =>
new Func <object>(() =>
new Func <object>(() => a)())();
var func = funcExpr.Compile();
var arg1 = new object();
Assert.AreSame(arg1, func(arg1));
var arg2 = new object();
Assert.AreSame(arg2, func(arg2));
var funcFec = ExpressionCompiler.TryCompile <Func <object, object> >(funcExpr);
Assert.AreSame(arg1, funcFec(arg1));
Assert.AreSame(arg2, funcFec(arg2));
}
public Delegate Compile(LambdaExpression expression) => ExpressionCompiler.TryCompile <Delegate>(expression) ?? fallback.Compile(expression);
public Func <T> Compile <T>(Expression <Func <T> > expression) => ExpressionCompiler.TryCompile <Func <T> >(expression) ?? fallback.Compile(expression);
public object CreateExpressionInfo_and_FastCompile()
{
var expr = ExpressionInfo.Lambda(ExpressionInfo.New(_xCtor, ExpressionInfo.New(_aCtor), ExpressionInfo.New(_bCtor)));
return(ExpressionCompiler.TryCompile <Func <object> >(expr));
}
