public object CreateExpressionInfo_and_FastCompile()
        {
            //Expression<Func<Action<string>>> expr = () => a => s.SetValue(a);

            var aParam = LE.Parameter(typeof(string), "a");
            var expr   = LE.Lambda(LE.Lambda(LE.Call(LE.Constant(_s), _setValueMethod, aParam), aParam));

            return(LEC.TryCompile <Func <Action <string> > >(expr));
        }
Esempio n. 2
0
        private LightExpression.Expression <Func <A> > CreateLightExpression()
        {
            var test           = L.Constant(new NestedLambdasVsVars());
            var getOrAddMethod = test.Type.GetMethod(nameof(GetOrAdd));
            var d = L.Convert(
                L.Call(test, getOrAddMethod,
                       L.Constant(2),
                       L.Lambda <Func <object> >(L.New(_dCtor), typeof(object))),
                typeof(D));

            var c = L.Convert(
                L.Call(test, getOrAddMethod,
                       L.Constant(1),
                       L.Lambda <Func <object> >(L.New(_cCtor, d), typeof(object))),
                typeof(C));

            var b = L.Convert(
                L.Call(test, getOrAddMethod,
                       L.Constant(0),
                       L.Lambda <Func <object> >(L.New(_bCtor, c, d), typeof(object))),
                typeof(B));

            return(L.Lambda <Func <A> >(L.New(_aCtor, b, c), typeof(A)));
        }