Is the famous library named Lucene? if so, I know there are some efforts to get 4.8 out. Thanks a lot for sharing, this is very useful.

Is there a performance advantage in using DynamicMethod, vs building a simple Expression tree and generating the lambda via Expression.Lamda<Action<PrivateRyan, bool>>(...).Compile() ? (not talking about the initial cost of generating the thing, but calling the resulting lambda at runtime)

I usually use Expression Trees for dynamic code, because they are simpler to maintain than having to understand the equivalent IL code.

Are you sure? I use them all the time to access non-public fields, methods, ctors, and even to deserialize structs/classes with auto-properties where I need to access the private backing fields.

For example, here is one of my helper methods, specifically to build "setters" for Fields (ignore the fact that the action takes object for the instance and params, it would work the same for typed args)

[CanBeNull]
public static Action<object, object> CompileSetter([NotNull] this FieldInfo field)
{
    Contract.NotNull(field, nameof(field));
    if (field.IsInitOnly) return null; // readonly
    
    // "void func(object instance, object value) { ((instance.TYPE)instance).Field = (value.TYPE)value); }"
    var prmInstance = Expression.Parameter(typeof(object), "instance");
    var prmValue = Expression.Parameter(typeof(object), "value");
    
    var body = Expression.Assign(Expression.Field(prmInstance.CastFromObject(field.DeclaringType), field), prmValue.CastFromObject(field.FieldType));
    return Expression.Lambda<Action<object, object>>(body, prmInstance, prmValue).Compile();
}
        
public static Expression CastFromObject([NotNull] this Expression expr, [NotNull] Type targetType)
{
    return expr.Type == targetType ? expr : targetType.IsClass ? Expression.TypeAs(expr, targetType) : targetType.IsValueType ? Expression.Unbox(expr, targetType) : Expression.Convert(expr, targetType);
}

Indeed, that is weird, because I thought that Compile() was just using an ExpressionTree Visitor that would Emit(..) the appropriate IL ? Maybe the JIT is doing magic under the covers?

I also tried using using Roslyn for codegen at runtime, because sometimes generating a string with the C# code that does what I want is a bit easier than cobbling together expression trees, especially when you need to build larger methods (like ones that deserialize all the fields of a struct in one go, instead of calling lots of smaller methods for each field). The startup cost of Roslyn is a lot higher, but if you are already using it for other things (like Razor views), it becomes "free". Only downside is that you can't do fancy stuff like calling into private/internal stuff.

A bit late, but I can explain why his code is faster. You see Christophe's code is closed over an object (in this case the empty closure object). You can get the same result by creating a dynamic method that closes over an empty object. Delegate invoke are modelled as instance calls, so if you aren't closing over anything it has to thunk shuffle your parameters.