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

Question

我有几个派生自抽象类 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)
});

我找到了很多关于如何调用泛型方法的描述，但无法让它发挥作用。

Answer 1

除了@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);
    }
}

问题是您正试图从运行时声明转到编译时泛型，因此只需创建一个工厂样式方法就足够了，您可以泛型调用它来为您构造委托(delegate)。 Program 中的 CreateMethod 方法将参与创建您的 lambda 表达式，然后您可以通过这种方式调用 BsonClassMap 上的静态方法。