使用反射调用传递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

这个问题有两个部分，

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

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

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

它最终最终要取决于您为其分配的内容，或者取决于编译器将其推断为的内容。 因此，要编写一个表达式，您需要编写的是Expression<Func<int>> e = () => 3;

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

如果此代码是完全通用的，则一种解决方案可能是使用一个辅助方法，该方法实际上返回您传入的表达式：

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/zh-cn/library/53cz7sc6.aspx

Answer 2

除了@ 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上调用静态方法。