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)); }