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＃中的lambdas可以有两种不同的类型。他们可以是代表（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

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);
    }
}

问题是你正试图从运行时声明转到编译时通用，所以只需创建一个工厂样式方法就可以了，你可以通常调用它来为你构造委托。 CreateMethod中的Program方法将参与制作lambda表达式，然后您可以通过BsonClassMap方式调用静态方法。

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

2 个答案: