使用反射调用传递 lambda 表达式的泛型方法

本文关键字：lambda 表达式 泛型方法 反射 调用 | 更新日期: 2023-09-27 18:34:44

我有几个从抽象类 A 派生的类 - A1、A2、A3 等。

我需要使用它们自己的鉴别器将这些类注册到 BsonClassMap，使用如下代码： 

BsonClassMap.RegisterClassMap<A1>(cm =>
{
    cm.AutoMap();
    cm.SetDiscriminator(discriminator)
});

由于将来我会有更多这样的类，我想使用反射来做到这一点： 

foreach (var type in Assembly.GetAssembly(typeof(A))
                             .GetTypes().Where(t => t.IsClass 
                                        && !t.IsAbstract 
                                        && t.IsSubclassOf(typeof(A))))
{
    var discriminator = type.GetField("Discriminator")
                            .GetRawConstantValue()
                            .ToString();
    var method = typeof(BsonClassMap).GetMethods()
                        .FirstOrDefault(m => m.IsGenericMethod 
                                             && m.Name == "RegisterClassMap");
    if (method == null) continue;
    var generic = method.MakeGenericMethod(type);
    generic.Invoke(this, null);
}

如何将这样的 lambda 表达式传递给此函数？ 

cm =>
{
    cm.AutoMap();
    cm.SetDiscriminator(discriminator)
});

我找到了很多关于如何调用泛型方法的描述，但无法使其工作。

使用反射调用传递 lambda 表达式的泛型方法

除了@aL3891发布的答案之外，我还模拟了一个简单的例子，说明我如何这样称呼它：

在这种情况下，SampleClass是BsonClassMap的替身，AbstractClass代表A，等等

class Program
{
    static void Main(string[] args)
    {
        SampleClass.Foo<int>(param =>
            {
            });
        var discoveredTypes = new List<Type>
        {
            typeof(DerivedOne),
            typeof(DerivedTwo),
            typeof(DerivedThree)
        };
        foreach (var type in discoveredTypes)
        {
            var methodType = typeof(Program).GetMethods().FirstOrDefault(x => x.Name == "CreateMethod").MakeGenericMethod(type);
            var method = methodType.Invoke(null, null);
            var staticMethod = typeof(SampleClass).GetMethods().FirstOrDefault(x => x.Name == "Foo").MakeGenericMethod(type);
            staticMethod.Invoke(null, new object[] { method });
        }
        Console.ReadKey();
    }
    public static Action<T> CreateMethod<T>()
    {
        return new Action<T>((param) =>
            {
                Console.WriteLine("This is being invoked with type: " + typeof(T).Name);
            });
    }
}
public abstract class AbstractClass { }
public class DerivedOne : AbstractClass { }
public class DerivedTwo : AbstractClass { }
public class DerivedThree : AbstractClass { }
public class SampleClass
{
    public static void Foo<TGenericType>(Action<TGenericType> setupMethod)
        where TGenericType : new()
    {
        TGenericType instance = new TGenericType();
        setupMethod(instance);
    }
}

问题是您正在尝试从运行时声明转到编译时泛型，因此只需创建一个工厂样式的方法就很容易，您可以通用地调用该方法来为您构造委托。Program 中的 CreateMethod 方法将参与制作 lambda 表达式，然后您可以通过这种方式在BsonClassMap上调用静态方法。

这个问题有两个部分，

要将 lambda 传递给此方法，您只需将其作为Invoke调用的第二个参数在数组中传递即可。 generic.Invoke(this, new object[]{foo});

但是，现在的问题是如何获取包含 lambda 的对象？这var l = () => {...}不起作用，那怎么办？

C# 中的 lambda 可以有两种不同的类型。它们可以是委托(Func<...>或Action<..>，也可以是表达式Expression<Func<...>>

它

实际上最终是什么取决于您将其分配给什么，或者更确切地说，编译器推断它是什么。所以你必须写什么才能得到一个表达式是Expression<Func<int>> e = () => 3;

现在，您可以将e传递到调用调用中(当然前提是表达式类型匹配(

如果此代码完全是泛型的，则一种解决方案可能是使用实际返回传入表达式的帮助程序方法：

public Action<T> GetMyDelegate<T>() where T: A{
  return (T cm) => {
    cm.AutoMap();
    cm.SetDiscriminator(discriminator)
  };
}

另请注意，您可以使用方法名称初始化委托，例如 Action： 

 public void Method1() {
   var a = new Action(Method2);
 }
 public void Method2()
 {  }

您还可以从MethodInfo创建委托，例如，如果A的不同子类型具有自己的 init 方法，您可以通过反射找到该方法：http://msdn.microsoft.com/en-us/library/53cz7sc6.aspx

相关文章：