FastExpressionCompiler 4.2.0

The ID prefix of this package has been reserved for one of the owners of this package by Prefix Reserved
dotnet add package FastExpressionCompiler --version 4.2.0
NuGet\Install-Package FastExpressionCompiler -Version 4.2.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="FastExpressionCompiler" Version="4.2.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add FastExpressionCompiler --version 4.2.0
#r "nuget: FastExpressionCompiler, 4.2.0"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install FastExpressionCompiler as a Cake Addin
#addin nuget:?package=FastExpressionCompiler&version=4.2.0

// Install FastExpressionCompiler as a Cake Tool
#tool nuget:?package=FastExpressionCompiler&version=4.2.0


<img src="./logo.png" alt="logo"/>

latest release notes Windows buildlicense

Targets .NET 6+, .NET 4.5+, .NET Standard 2.0+

NuGet packages:

  • FastExpressionCompiler NuGet Badge
    • sources package: FastExpressionCompiler.src NuGet Badge
    • sources with the public code made internal: FastExpressionCompiler.Internal.src NuGet Badge
  • FastExpressionCompiler.LightExpression NuGet Badge
    • sources package: FastExpressionCompiler.LightExpression.src NuGet Badge
    • sources with the public code made internal: FastExpressionCompiler.LightExpression.Internal.src NuGet Badge

The project was originally a part of the DryIoc, so check it out 😉

The problem

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


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.

See also a deep dive to Delegate internals.

The solution

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

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

In addition, the memory consumption taken by the compilation will be much smaller (check the Allocated column in the benchmarks below).


Updated to .NET 8.0

BenchmarkDotNet v0.13.10, Windows 11 (10.0.22621.2428/22H2/2022Update/SunValley2)
11th Gen Intel Core i7-1185G7 3.00GHz, 1 CPU, 8 logical and 4 physical cores
.NET SDK 8.0.100-rc.2.23502.2
[Host]     : .NET 8.0.0 (, X64 RyuJIT AVX2
DefaultJob : .NET 8.0.0 (, X64 RyuJIT AVX2

Hoisted expression with the constructor and two arguments in closure

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

Compiling expression:

Method Mean Error StdDev Median Ratio RatioSD Gen0 Gen1 Allocated Alloc Ratio
Compile 121.969 us 2.4180 us 5.6040 us 120.830 us 35.77 2.46 0.7324 - 4.49 KB 2.92
CompileFast 3.406 us 0.0677 us 0.1820 us 3.349 us 1.00 0.00 0.2441 0.2365 1.54 KB 1.00

Invoking the compiled delegate (comparing to the direct constructor call):

Method Mean Error StdDev Median Ratio RatioSD Gen0 Allocated Alloc Ratio
DirectConstructorCall 5.734 ns 0.1501 ns 0.2745 ns 5.679 ns 0.86 0.05 0.0051 32 B 1.00
CompiledLambda 6.857 ns 0.1915 ns 0.5434 ns 6.704 ns 1.01 0.09 0.0051 32 B 1.00
FastCompiledLambda 6.746 ns 0.1627 ns 0.1442 ns 6.751 ns 1.00 0.00 0.0051 32 B 1.00

Hoisted expression with the static method and two nested lambdas and two arguments in closure

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:

Method Mean Error StdDev Ratio RatioSD Gen0 Gen1 Allocated Alloc Ratio
Compile 442.02 us 8.768 us 21.998 us 40.00 2.34 1.9531 0.9766 12.04 KB 2.61
CompileFast 11.06 us 0.221 us 0.441 us 1.00 0.00 0.7324 0.7019 4.62 KB 1.00

Invoking compiled delegate comparing to direct method call:

Method Mean Error StdDev Ratio RatioSD Gen0 Allocated Alloc Ratio
DirectMethodCall 35.51 ns 0.783 ns 1.308 ns 0.86 0.08 0.0267 168 B 1.62
Invoke_Compiled 1,096.15 ns 21.507 ns 41.437 ns 27.15 2.75 0.0420 264 B 2.54
Invoke_CompiledFast 37.65 ns 1.466 ns 4.299 ns 1.00 0.00 0.0166 104 B 1.00

Manually composed expression with parameters and closure

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

Compiling expression:

Method Mean Error StdDev Median Ratio RatioSD Gen0 Gen1 Allocated Alloc Ratio
Compile_SystemExpression 89.076 us 2.6699 us 7.6605 us 85.180 us 28.12 3.05 0.7324 0.4883 4.74 KB 3.41
CompileFast_SystemExpression 3.138 us 0.0550 us 0.0565 us 3.118 us 0.99 0.03 0.2213 0.2136 1.39 KB 1.00
CompileFast_LightExpression 3.180 us 0.0602 us 0.0591 us 3.163 us 1.00 0.00 0.2213 0.2136 1.39 KB 1.00

Invoking the compiled delegate compared to the normal delegate and the direct call:

Method Mean Error StdDev Median Ratio RatioSD Gen0 Allocated Alloc Ratio
DirectCall 8.388 ns 0.2655 ns 0.7575 ns 8.092 ns 1.00 0.07 0.0051 32 B 1.00
Compiled_SystemExpression 9.474 ns 0.1870 ns 0.4105 ns 9.381 ns 1.10 0.05 0.0051 32 B 1.00
CompiledFast_SystemExpression 8.575 ns 0.1624 ns 0.1440 ns 8.517 ns 1.00 0.02 0.0051 32 B 1.00
CompiledFast_LightExpression 8.584 ns 0.0776 ns 0.0862 ns 8.594 ns 1.00 0.00 0.0051 32 B 1.00

FastExpressionCompiler.LightExpression.Expression vs System.Linq.Expressions.Expression

FastExpressionCompiler.LightExpression.Expression is the lightweight version of System.Linq.Expressions.Expression. It is designed to be a drop-in replacement for the System Expression - just install the FastExpressionCompiler.LightExpression package instead of FastExpressionCompiler and replace the usings

using System.Linq.Expressions;
using static System.Linq.Expressions.Expression;


using static FastExpressionCompiler.LightExpression.Expression;
namespace FastExpressionCompiler.LightExpression.UnitTests

You may look at it as a bare-bone wrapper for the computation operation node which helps you to compose the computation tree (without messing with the IL emit directly). It won't validate operations compatibility for the tree the way System.Linq.Expression does it, and partially why it is so slow. Hopefully you are checking the expression arguments yourself and not waiting for the Expression exceptions to blow-up.

Sample expression

Creating the expression:

Method Mean Error StdDev Ratio RatioSD Gen0 Allocated Alloc Ratio
Create_SystemExpression 1,039.5 ns 20.75 ns 45.98 ns 8.29 0.50 0.2060 1304 B 2.63
Create_LightExpression 125.7 ns 2.46 ns 5.99 ns 1.00 0.00 0.0789 496 B 1.00
Create_LightExpression_with_intrinsics 130.0 ns 2.47 ns 6.25 ns 1.04 0.07 0.0777 488 B 0.98

Creating and compiling:

Method Mean Error StdDev Ratio RatioSD Gen0 Gen1 Allocated Alloc Ratio
Create_SystemExpression_and_Compile 159.184 us 2.9731 us 7.1235 us 37.34 1.65 0.9766 0.4883 7.4 KB 3.06
Create_SystemExpression_and_CompileFast 5.923 us 0.0996 us 0.1771 us 1.34 0.05 0.5188 0.5035 3.27 KB 1.35
Create_LightExpression_and_CompileFast 4.399 us 0.0484 us 0.0453 us 1.00 0.00 0.3815 0.3662 2.42 KB 1.00
CreateLightExpression_and_CompileFast_with_intrinsic 4.384 us 0.0835 us 0.0697 us 1.00 0.02 0.3815 0.3662 2.35 KB 0.97

Difference between FastExpressionCompiler and FastExpressionCompiler.LightExpression


  • Provides the CompileFast extension methods for the System.Linq.Expressions.LambdaExpression.


  • Provides the CompileFast extension methods for FastExpressionCompiler.LightExpression.LambdaExpression.
  • Provides the drop-in expression replacement with the less consumed memory and the faster construction at the cost of the less validation.
  • Includes its own ExpressionVisitor.
  • Supports ToExpression method to convert back to the System.Linq.Expressions.Expression.

Both FastExpressionCompiler and FastExpressionCompiler.LightExpression

  • Support ToCSharpString() method to output the compile-able C# code represented by expression.
  • Support ToExpressionString() method to output the expression construction C# code, so given the expression object you'll get e.g. Expression.Lambda(Expression.New(...)).

Who's using it

Marten, Rebus, StructureMap, Lamar, ExpressionToCodeLib, NServiceBus, LINQ2DB, MapsterMapper

Considering: Moq, Apex.Serialization

How to use

Install from the NuGet and add the using FastExpressionCompiler; and replace the call to the .Compile() with the .CompileFast() extension method.

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


Hoisted lambda expression (created by the C# 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.Constant(a, typeof(A)), bParamExpr),

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

Note: You may simplify Expression usage and enable faster refactoring with the C# using static statement:

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

var a = new A();
var bParamExpr = Parameter(typeof(B), "b");
var expr = Lambda(
    New(_ctorX, Constant(a, typeof(A)), bParamExpr),

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

How it works

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

What's not supported yet

FEC does not support yet:

  • Quote
  • Dynamic
  • RuntimeVariables
  • DebugInfo
  • MemberInit with the MemberMemberBinding and the ListMemberBinding binding types
  • NewArrayInit multi-dimensional array initializer is not supported yet

To find what nodes are not supported in your expression you may use the technic described below in the Diagnostics section.

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

The expression is traversed twice:

  • 1st round is to collect the constants and nested lambdas into the closure objects.
  • 2nd round is to emit the IL code and create the delegate using the DynamicMethod.

If visitor finds the not supported expression node or the error condition, the compilation is aborted, and null is returned enabling the fallback to System .Compile().

Diagnostics and Code Generation

FEC V3 has added powerful diagnostics and code generation tools.


You may pass the optional CompilerFlags.EnableDelegateDebugInfo into the CompileFast methods.

EnableDelegateDebugInfo adds the diagnostic info into the compiled delegate including its source Expression and C# code. Can be used as following:

var f = e.CompileFast(true, CompilerFlags.EnableDelegateDebugInfo);
var di = f.Target as IDelegateDebugInfo;

ThrowOnNotSupportedExpression and NotSupported_ flags

FEC V3.1 has added the compiler flag CompilerFlags.ThrowOnNotSupportedExpression. When passed to CompileFast(flags: CompilerFlags.ThrowOnNotSupportedExpression) and the expression contains not (yet) supported Expression node the compilation will throw the exception instead of returning null.

To get the whole list of the not yet supported cases you may check in Result.NotSupported_ enum values.

Code Generation

The Code Generation capabilities are available via the ToCSharpString and ToExpressionString extension methods.

Note: When converting the source expression to either C# code or to the Expression construction code you may find the // NOT_SUPPORTED_EXPRESSION comments marking the not supported yet expressions by FEC. So you may test the presence or absence of this comment.

Additional optimizations

  1. Using FastExpressionCompiler.LightExpression.Expression instead of System.Linq.Expressions.Expression for the faster expression creation.
  2. Using .TryCompileWithPreCreatedClosure and .TryCompileWithoutClosure methods when you know the expression at hand and may skip the first traversing round, e.g. for the "static" expression which does not contain the bound constants. Note: You cannot skip the 1st round if the expression contains the Block, Try, or Goto expressions.

<a target="_blank" href="">Bitten Ice Pop icon</a> icon by <a target="_blank" href="">Icons8</a>

Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 is compatible.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 is compatible. 
.NET Framework net45 is compatible.  net451 was computed.  net452 was computed.  net46 was computed.  net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (54)

Showing the top 5 NuGet packages that depend on FastExpressionCompiler:

Package Downloads

Rules Engine is a package for abstracting business logic/rules/policies out of the system. This works in a very simple way by giving you an ability to put your rules in a store outside the core logic of the system thus ensuring that any change in rules doesn't affect the core system.


Code Generation Chicanery for .Net


DotVVM is an open source ASP.NET-based framework which allows to build interactive web apps easily by using mostly C# and HTML.


Miruken handles your application


*TestBase* gives you a flying start with - fluent assertions that are easy to extend - sharp error messages - tools to help you test with “heavyweight” dependencies on - AspNetCore.Mvc, AspNet.Mvc or WebApi Contexts - HttpClient - Ado.Net - Streams & Logging - Mix & match with your favourite test runners & assertions. ``` UnitUnderTest.Action() .ShouldNotBeNull() .ShouldEqualByValueExceptFor(new {Id=1, Descr=expected}, ignoreList ) .Payload .ShouldMatchIgnoringCase("I expected this") .Should(someOtherPredicate); .Items .ShouldAll(predicate) .ShouldContain(item) .ShouldNotContain(predicate) .Where(predicate) .SingleOrAssertFail() .ShouldEqualByValue().ShouldEqualByValueExceptFor(...).ShouldEqualByValueOnMembers() work with all kinds of object and collections, and report what differed. string.ShouldMatch(pattern).ShouldNotMatch().ShouldBeEmpty().ShouldNotBeEmpty() .ShouldNotBeNullOrEmptyOrWhiteSpace().ShouldEqualIgnoringCase() .ShouldContain().ShouldStartWith().ShouldEndWith().ShouldBeContainedIn(), ... numeric.ShouldBeBetween().ShouldEqualWithTolerance()....GreaterThan....LessThan...GreaterOrEqualTo ... ienumerable.ShouldAll().ShouldContain().ShouldNotContain().ShouldBeEmpty().ShouldNotBeEmpty() ... stream.ShouldHaveSameStreamContentAs().ShouldContain() value.ShouldBe().ShouldNotBe().ShouldBeOfType().ShouldBeAssignableTo()... ``` TestBase.HttpClient.Fake ``` new FakeHttpClient() .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/this")) .Returns(response) .Setup(x=>x.Method==HttpMethod.Put) .Returns(new HttpResponseMessage(HttpStatusCode.Accepted)); ``` TestBase.AdoNet ------------------ `FakeDbConnection` ``` - db.SetupForQuery(…) - db.SetupForExecuteNonQuery(…) - db.ShouldHaveUpdated("tableName", …) - db.ShouldHaveSelected("tableName", …) - db.ShouldHaveDeleted("tableName", …) - db.Verify( x=>x.CommandText.Matches("Insert [case] .*") && x.Parameters["id"].Value==1 ) - db .ShouldHaveInvoked(cmd => predicate(cmd)) .ShouldHaveParameter("name", value) ``` `RecordingDbConnection` TestBase.Mvc.AspNetCore & TestBase.Mvc for Mvc 4 & Mvc 5 -------------------------------------------------------- ``` ControllerUnderTest.WithControllerContext() .Action() .ShouldbeViewResult() .ShouldHaveModel<TModel>() .ShouldEqualByValue(expected) ControllerUnderTest.Action() .ShouldBeRedirectToRouteResult() .ShouldHaveRouteValue("expectedKey", [Optional] "expectedValue"); ShouldHaveViewDataContaining(), ShouldBeJsonResult() etc. ``` - Test AspNetCore controllers with zero setup using `controllerUnderTest.WithControllerContext(actionUnderTest)` - Test more complex AspNetCore controller/application dependencies using `HostedMvcTestFixtureBase` and specify your MVCApplications `Startup` class. ``` [TestCase("/dummy")] public async Task Put_Should_ReturnA(string url) { var httpClient=GivenClientForRunningServer<Startup>(); GivenRequestHeaders(httpClient, "CustomHeader", "HeaderValue1"); var result = await httpClient.PutAsync(url, json); result.ShouldBe_202Accepted(); } ``` For Mvc4 and Mvc 5, fake your http request &amp; context, and use the `RegisterRoutes` method of your actual application to set up `Controller.Url` ``` ControllerUnderTest .WithHttpContextAndRoutes( RouteConfig.RegisterRoutes, "/incomingurl" ); ApiControllerUnderTest.WithWebApiHttpContext<T>( httpMethod, requestUri, routeTemplate) ``` Testable Logging ``` // Extensions.Logging.ListOfString var log = new List<String>(); ILogger mslogger= new LoggerFactory().AddStringListLogger(log).CreateLogger("Test2"); // Serilog.Sinks.ListOfString Serilog.Logger slogger= new LoggerConfiguration().WriteTo.StringList(log).CreateLogger(); ```

GitHub repositories (12)

Showing the top 5 popular GitHub repositories that depend on FastExpressionCompiler:

Repository Stars
A fast, fun and stimulating object to object Mapper
A Json based Rules Engine with extensive Dynamic expression support
Supercharged .NET server side development!
该仓库为 的镜像仓库,代码更新存在较大的延迟。建议前往源仓库:
Version Downloads Last updated
4.2.0 20,339 4/29/2024
4.1.0 309,543 1/20/2024
4.0.2 307 1/20/2024
4.0.1 226,899 11/23/2023
4.0.0 767,912 11/12/2023
3.4.0-preview-01 2,481 8/19/2023
3.3.4 1,568,827 1/17/2023
3.3.3 2,124,242 7/24/2022
3.3.2 87,808 5/27/2022
3.3.1 23,591 5/25/2022
3.3.0 23,403 4/26/2022
3.2.2 328,957 2/2/2022
3.2.1 1,294,579 7/21/2021
3.2.0 266,516 6/14/2021
3.1.0 120,493 5/3/2021
3.1.0-preview-03 227 5/3/2021
3.1.0-preview-02 238 5/3/2021
3.1.0-preview-01 235 5/2/2021
3.0.6-preview-01 255 4/23/2021
3.0.5 4,064 4/21/2021
3.0.4 6,478 4/6/2021
3.0.3 1,542 4/1/2021
3.0.2 7,210 3/30/2021
3.0.1 504 3/27/2021
3.0.0 1,464 3/17/2021
3.0.0-preview-07 7,516 12/25/2020
3.0.0-preview-06 491 12/1/2020
3.0.0-preview-05 1,334 11/27/2020
3.0.0-preview-04 501 11/3/2020
3.0.0-preview-03 316 11/2/2020
3.0.0-preview-02 4,152 10/23/2020
3.0.0-preview-01 338 10/23/2020
2.0.0 746,349 1/25/2019
2.0.0-preview-03 1,324 11/9/2018
2.0.0-preview-02 1,022 10/25/2018
2.0.0-preview-01 765 10/24/2018
1.10.1 82,823 8/8/2018
1.10.0 1,048 8/3/2018
1.9.0 1,588 7/24/2018
1.8.0 34,492 6/24/2018
1.7.2 12,655 6/7/2018
1.7.1 180,047 3/27/2018
1.7.0 6,996 3/17/2018
1.6.0 48,577 12/3/2017
1.5.0 3,174 11/12/2017
1.4.0 16,013 9/9/2017
1.3.0 1,591 8/28/2017
1.2.2 1,737 8/8/2017
1.2.1 1,306 8/8/2017
1.2.0 1,271 8/8/2017
1.1.1 178,408 7/18/2017
1.1.0 1,168 7/13/2017
1.0.1 2,061 5/26/2017
1.0.0 4,621 4/2/2017
1.0.0-preview-04 1,061 3/31/2017
1.0.0-preview-03 1,597 3/30/2017
1.0.0-preview-02 1,043 3/29/2017
1.0.0-preview-01 1,137 3/23/2017

## v4.2.0 Feature and bug-fix release

- feat: #133 Optimize Switch Expression
- feat: #393 Support ToCSharpString of the block in the ternary expression
- feat: #396 Optimize conditional expressions with the DefaultExpression left or right operand the same way as ConstantExpression

- fix: #390 System.AccessViolationException when mapping using Mapster
- fix: #391 ToCSharpString outputs ? for Nullable which does not produce the compile-able code
- fix: #392 ToExpressionString wrongly declares Label instead of LabelTarget array
- fix: #394 Calling a user defined == operator runs into a CLR invalid program exception
- fix: #397 Fix and optimize the Switch support
- fix: #399 Coalesce nullable with 0 is not working
- fix: #400 Fix the direct assignment of Try to Member expression because indirect assignment through tmp var works
- fix: #401 Invoke inlining is not working with collections in AutoMapper tests
- fix: #404 An expression with a single parameter concatenated to a string causes 'Exception has been thrown by the target of an invocation' during delegate invocation
- fix: #405 NullReferenceException with V4.X when using long?[]
- fix: #406 NullReferenceException with V4.X
- fix: #407 NullReferenceException when setting the Enum field
- fix: #408 Dictionary mapping failing when the InvocationExpression inlining is involved

## v4.1.0 Small feature and bug-fix release

- added: #379 Add direct net8.0 target as soon as Appveyor CI will support it
- fixed: #380 Comparisons with nullable types
- fixed: #381 NullReferenceException with V4.X when trying to map
- fixed: #386 Value can not be null(parametr 'meth')

## v4.0.1 Bug-fix release

- fixed: #374 CompileFast doesn't work with HasFlag

## v4.0.0 Major release

- fixed: #352 xxxAssign doesn't work with MemberAccess
- fixed: #353 NullReferenceException when calling CompileFast() results
- fixed: #357 Invalid program exception
- fixed: #366 FastExpressionCompiler[v3.3.4] gives incorrect results in some linq operations
- fixed: #368 Fix duplicate nested lambda compilation
- fixed: #374 CompileFast doesn't work with HasFlag

- added: #264 Optimize the array index emit to emit specific Ldelem_ code instead of generic Ldelem
- added: #273 Implement IArgumentProvider for the BlockExpression to minimize the consumed memory
- added: #346 Is it possible to implement ref local variables?
- added: #359 Improve the performance of variable lookup
- added: #367 Better diagnostics and debugging with error codes from Collect and Compile rounds
- added: #369 Decrease memory occupied by the LightExpression Block by storing Expression in SmallList (partly on stack)
- added: #370 Optimize any nested lambda compilation (LINQ) by compiling right after collect one-by-one
- added: #372 Support LightExpression.Expression.TryConvertDelegateIntrinsic for converting one type of delegate to another
- added: #373 Support custom C# printing for the LightExpression.Expression