• Windows:
• Linux, MacOS:

Supported platforms: .NET 4.5+, .NET Standard 1.3 Originally developed as part of DryIoc, so give it a look :-)

ExpressionTree compilation is used by wide range of tools, e.g. IoC/DI containers, Serializers, OO Mappers. But Expression.Compile() is just slow. Moreover, the compiled delegate may be slower than manually created delegate because of the reasons:

TL;DR;

Expression.Compile creates a DynamicMethod and associates it with an anonymous assembly to run it in a sand-boxed environment. This makes it safe for a dynamic method to be emitted and executed by partially trusted code but adds some run-time overhead.

.CompileFast() is 10-40x times faster than .Compile().
The compiled delegate may be in some cases 15x times faster than the one produced by .Compile().

Note: The actual performance may vary depending on multiple factors: platform, how complex is expression, does it have a closure over the values, does it contain nested lambdas, etc.

Install from NuGet or grab a single FastExpressionCompiler.cs file.

Marten, Rebus, StructureMap, Lamar, ExpressionToCodeLib.

Considering: NServiceBus, Moq

Add reference to FastExpressionCompiler and replace call to .Compile() with .CompileFast() extension method.

Note: CompileFast has an optional parameter bool ifFastFailedReturnNull = false to disable fallback to Compile.

Hoisted lambda expression (created by compiler):

var a = new A(); var b = new B();
Expression<Func<X>> expr = () => new X(a, b);

var getX = expr.CompileFast();
var x = getX();

Manually composed lambda expression:

var a = new A();
var bParamExpr = Expression.Parameter(typeof(B), "b");
var expr = Expression.Lambda(
    Expression.New(typeof(X).GetTypeInfo().DeclaredConstructors.First(),
        Expression.Constant(a, typeof(A)), bParamExpr),
    bParamExpr);

var getX = expr.CompileFast();
var x = getX(new B());

Using ExpressionInfo instead of Expression:

var a = new A();
var bParamExpr = ExpressionInfo.Parameter(typeof(B), "b");
var expr = ExpressionInfo.Lambda(
    ExpressionInfo.New(typeof(X).GetTypeInfo().DeclaredConstructors.First(),
        ExpressionInfo.Constant(a, typeof(A)), bParamExpr),
    bParamExpr);

var getX = expr.CompileFast();
var x = getX(new B());

Note: Simplify your life in C# 6+ with using static

using static System.Linq.Expressions.Expression;
// or
//  using static FastExpressionCompiler.ExpressionInfo;

var a = new A();
var bParamExpr = Parameter(typeof(B), "b");
var expr = Lambda(
    New(typeof(X).GetTypeInfo().DeclaredConstructors.First(), Constant(a, typeof(A)), bParamExpr),
    bParamExpr);

var x = expr.CompileFast()(new B());

BenchmarkDotNet=v0.11.0, OS=Windows 10.0.14393.2248 (1607/AnniversaryUpdate/Redstone1)
Intel Core i5-6300U CPU 2.40GHz (Skylake), 1 CPU, 4 logical and 2 physical cores
Frequency=2437501 Hz, Resolution=410.2562 ns, Timer=TSC
  [Host] : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
  Clr    : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
  Core   : .NET Core 2.0.9 (CoreCLR 4.6.26614.01, CoreFX 4.6.26614.01), 64bit RyuJIT

var a = new A();
var b = new B();
Expression<Func<X>> e = () => new X(a, b);

Compiling expression:

Invoking compiled delegate comparing to direct constructor call:

var a = new A();
var b = new B();
Expression<Func<X>> getXExpr = () => CreateX((aa, bb) => new X(aa, bb), new Lazy<A>(() => a), b);

Compiling expression:

Invoking compiled delegate comparing to direct method call:

var a = new A();
var bParamExpr = Expression.Parameter(typeof(B), "b");
var expr = Expression.Lambda(
    Expression.New(typeof(X).GetTypeInfo().DeclaredConstructors.First(),
        Expression.Constant(a, typeof(A)), bParamExpr),
    bParamExpr);

Compiling expression:

Invoking compiled delegate comparing to normal delegate:

FastExpressionCompiler.ExpressionInfo is the lightweight version of Expression. You may look at it as just a thin wrapper on operation node which helps you to compose the computation tree. But it won't do any node compatibility verification for the tree as the Expression does (and why it is slow). Hopefully, you are checking the expression arguments yourself, and not waiting for Expression exceptions to blow up.

Note: At the moment ExpressionInfo is not supported for all supported expression types (#46).

Sample expression

Creating expression:

Creating and compiling:

The idea is to provide fast compilation for supported expression types, and fallback to system Expression.Compile() for not yet supported types.

Note: As of v1.9 most of the types are supported, please open issue if something is not ;-)

Compilation is done by visiting expression nodes and emitting the IL. The code is tuned for performance and minimal memory consumption.

Expression is visited in two rounds (you can skip the first one with up-front knowledge):

1. To collect constants and nested lambdas into closure objects
2. To emit the IL and create the delegate from a DynamicMethod

If visitor finds a not supported expression node, the compilation is aborted, and null is returned enabling the fallback to normal .Compile().

1. Using ExpressionInfo instead of Expression for lightweight expression creation.
   Won't speed-up compilation alone, but may speed-up construction+compilation.
2. Using expr.TryCompileWithPreCreatedClosure and expr.TryCompileWithoutClosure when you know the expression at hand and may optimize for delegate with closure or for "static" delegate.

Both optimizations are visible in benchmark results: search for ExpressionInfo and FastCompiledLambdaWithPreCreatedClosure respectively.