通过 ILGenerator 调用带谓词表达式的 LINQ

Question

我正在尝试通过在运行时发出 IL 来编译 DynamicMethod。我希望它执行以下操作：

array.OrderByDesc( /* Select Field/Property Expression*/ ).ToArray();

编译 DynamicMethod 的方法有一个 FieldInfo 变量，我想将其用于 OrderByDesc 需要的表达式。

这是我目前的情况：

public static FilterDelegate<T> CreateDelegate<T>( Expression<Func<T, double>> expression )
{
  var field = expression.GetFieldInfo();// Extension, gets FieldInfo from expression
  ...
  il.Emit( OpCodes.Ldloc_1 ); // Loads an array (T[])
  il.Emit( OpCodes.Call, typeof( Enumerable ).GetMethod( nameof( Enumerable.OrderByDescending ), new Type[0]).MakeGenericMethod( typeof( T ) ) );
  il.Emit( OpCodes.Call, typeof( Enumerable ).GetMethod( nameof( Enumerable.ToArray ) ).MakeGenericMethod( typeof( T ) ) );
  il.Emit( OpCodes.Stloc_1 ); // Stores the sorted array
}

注意几点：

提供的表达式是一个选择器，指定在整个编译方法中使用哪个字段（或属性后备值）。
此方法不仅仅调用 OrderByDescending()，还包含大量低级优化。排除排序，预计在大多数情况下运行在40ns以内。

如何使用传递给编译方法的表达式或 FieldInfo 来正确调用 OrderByDescending()？

Answer 1

我不完全理解你试图通过直接 IL 生成实现什么； OrderByDescending 接受一个名为 "keySelector" 的 Func<TSource, TKey> 参数。因此，您仍然可以在使用此方法的同时生成的唯一 IL 只是一个常规方法调用，它将 "keySelector" 参数传递给 OrderByDescending 方法，除非您打算在 IL 中重新实现 OrderByDescending .

你有什么理由需要一路下降到 IL 吗？

如果这是针对用户级代码，您可以 "Compile" 将传递给此方法的 expression 并正常调用 OrderByDescending()，例如

var expression = /* Select Field/Property Expression*/;
array.OrderByDescending(expression.Compile()).ToArray();

如果这是 framework/utility 级代码，您可能会使用 "Expression trees" 而无需一直使用手动 IL。例如

public static FilterDelegate<T> CreateDelegate<T>(Expression<Func<T, double>> expression)
{
    var parameter = Expression.Parameter(typeof(IEnumerable<T>), "source");

    // Your `GetMethod` for OrderByDescending did not work for me,
    // so I'll just hand wave about this.
    var orderByDescMethod = typeof(Enumerable)
        .GetMethods()
        .Single(m => m.Name == nameof(Enumerable.OrderByDescending) &&
                     m.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(T), typeof(double));

    var toArrayMethod = typeof(Enumerable)
        .GetMethod(nameof(Enumerable.ToArray))
        .MakeGenericMethod(typeof(T));

    var orderByExpression = Expression.Call(orderByDescMethod, parameter, expression);
    var lambdaBody = Expression.Call(toArrayMethod, orderByExpression);
    var lambdaExpression = Expression.Lambda<FilterDelegate<T>>(lambdaBody, parameter);

    return lambdaExpression.Compile();
}

但是，如果出于某种原因您仍然需要通过 IL 直接发出此消息，则可以使用类似以下的方法。

public static FilterDelegate<T> CreateDelegate<T>(Expression<Func<T, double>> expression)
{
    // Your `GetMethod` for OrderByDescending did not work for me,
    // so I'll just hand wave about this.
    var orderByDescMethod = typeof(Enumerable)
                            .GetMethods()
                            .Single(m => m.Name == nameof(Enumerable.OrderByDescending) &&
                                         m.GetParameters().Length == 2)
                            .MakeGenericMethod(typeof(T), typeof(double));

    var toArrayMethod = typeof(Enumerable)
                        .GetMethod(nameof(Enumerable.ToArray))
                        .MakeGenericMethod(typeof(T));

    // TODO: if you don't already have one of these
    //       you'll probably want to pull this out and re-use it
    //       rather than making a new one for every delegate
    // TODO: if you do share a module builder I don't think it's thread-safe
    //       so this method will need sufficient locking/synchronization
    var dynamicAssemblyName = new AssemblyName { Name = $"{Guid.NewGuid()}" };
    var asm = AppDomain.CurrentDomain.DefineDynamicAssembly(dynamicAssemblyName, AssemblyBuilderAccess.Run);
    var module = asm.DefineDynamicModule(dynamicAssemblyName.Name);

    // Create a class with a static field to hold our compiled expression
    var typeBuilder = module.DefineType(
        $"{Guid.NewGuid()}",
        TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Serializable);

    var compiledExpressionField = typeBuilder.DefineField(
        "CompiledExpression",
        typeof(Func<T, double>),
        FieldAttributes.Static | FieldAttributes.Private);

    var holderType = typeBuilder.CreateType();

    var compiledExpression = expression.Compile();

    // Get the actual field after we've compiled the type
    var compiledExpressionFieldInfo = holderType.GetField(
        compiledExpressionField.Name,
        BindingFlags.Static | BindingFlags.NonPublic);

    // Store the compiled expression in the static field
    compiledExpressionFieldInfo.SetValue(null, compiledExpression);

    var newDelegate = new DynamicMethod($"{Guid.NewGuid()}",
        typeof(IOrderedEnumerable<T>),
        new[] { typeof(IEnumerable<T>) },
        typeof(ILGen), true);

    var il = newDelegate.GetILGenerator();

    // Load the array passed into the Delegate (T[])
    il.Emit(OpCodes.Ldarg_0);
    // Load the compiled expression from a static field
    il.Emit(OpCodes.Ldsfld, compiledExpressionFieldInfo);
    // Call .OrderByDescending()
    il.Emit(OpCodes.Call, orderByDescMethod);
    // Call .ToArray()
    il.Emit(OpCodes.Call, toArrayMethod);
    il.Emit(OpCodes.Ret); // Stores the sorted array

    return (FilterDelegate<T>)newDelegate.CreateDelegate(typeof(FilterDelegate<T>));
}

通过 ILGenerator 调用带谓词表达式的 LINQ

Calling LINQ with predicate expression through ILGenerator

c#

linq

cil