将具有泛型方法的接口实例转换为操作

Question

我正在努力使用可以使用反射检索的MethodInfo 创建Action<> 的实例。

使用下面的示例，我可以轻松地在我的对象上调用自定义方法，但我真的很想将它们转换为动作。

我已经尝试使用 Delegate.CreateDelegate 来实现它，但我似乎无法让它返回一个泛型类型的 Action。

示例

我已经创建了如下界面：

interface IMyTest { } // Marker interface
interface<TInput> IMyTest : IMyTest {
    void MyMethod(TInput input);
}

然后我在一个类中继承接口：

class MyClass : IMyTest<DateTime>, IMyTest<int> {
    void MyMethod(DateTime input) {
        // Do something
    }
    void MyMethod(int input) {
        // Do something else
    }
}

然后我创建一个使用反射从接口实例中查找并调用“MyMethod”的方法：

void DoCallMyMethod(object target, object input) {
    IEnumerable<Type> interfaces = target.GetType().GetInterfaces()
        .Where(x => typeof(IMyTest).IsAssignableFrom(x) && x.IsGenericType);

    foreach (Type @interface in interfaces) {
        Type type = @interface.GetGenericArguments()[0];
        MethodInfo method = @interface.GetMethod("MyMethod", new Type[] { type });

        if (method != null) {
            method.Invoke(target, new[] { input });
        }
    }
}

最后我把它们放在一起：

MyClass foo = new MyClass();
DoCallMyMethod(foo, DateTime.Now);
DoCallMyMethod(foo, 47);

我想要什么

在DoCallMyMethod 内部，我希望将MethodInfo method 转换为通用Action，以便结果如下所示：

Action<type> myAction = method;

但这显然行不通。

我发现了一些类似的 SO 帖子（但没有一个完全涵盖我的情况），最终得到的答案类似于：

Action<object> action = 
    (Action<object>)Delegate.CreateDelegate(typeof(Action<object>), target, method);

但这不起作用，因为“无法绑定到目标方法，因为它的签名或安全透明度与委托类型的不兼容。”

我怎样才能得到一个以指定type 作为输入类型的动作，同时仍然保留对象引用（不出现新实例）？

Answer 1

您不能从MyMethods 之一创建Action<object>，因为该方法需要特定对象的类型（int、DateTime），如果您将其视为Action<object>，您可能会调用它与任何类型的对象。

由于您需要返回一个Action<T>，因此无需将输入值传递给DoCallMyMethod 方法。您可以将输入类型作为泛型参数传递：

public Action<T> DoCallMyMethod<T>(object target)
{
    var @interface = typeof(IMyTest<T>);
    if (@interface.IsAssignableFrom(target.GetType()))
    {
        var method = @interface.GetMethod("MyMethod");
        if (method != null)
        {
            var action = Delegate.CreateDelegate(typeof(Action<T>), target, method) as Action<T>;                    
            return action;
        }
    }

    return null;
}

然后，像这样使用它：

MyClass foo = new MyClass();
var action1 = DoCallMyMethod<DateTime>(foo);
var action2 = DoCallMyMethod<int>(foo);

action1(DateTime.Now);
action2(47);

如果你在编译时不知道输入的类型，你可以试试这个：

public Delegate DoCallMyMethod(object target, Type inputType)
{
    var @interface = typeof(IMyTest<>).MakeGenericType(inputType);
    if (@interface.IsAssignableFrom(target.GetType()))
    {
        var method = @interface.GetMethod("MyMethod");
        if (method != null)
        {
            var @delegate = Delegate.CreateDelegate(typeof(Action<>).MakeGenericType(inputType), target, method);
            return @delegate;
        }
    }

    return null;
}

然后像这样使用它：

MyClass foo = new MyClass();
var action1 = DoCallMyMethod(foo, typeof(DateTime)) as Action<DateTime>;
var action2 = DoCallMyMethod(foo, typeof(int)) as Action<int>;

action1(DateTime.Now);
action2(47);

//or

int input = 47;
var @delegate = DoCallMyMethod(foo, input.GetType());
@delegate.DynamicInvoke(input);

但是如果你需要返回一个Action<object>，你可以做一个动作来接收一个对象并在对象的类型有效的情况下调用该方法：

public Action<object> DoCallMyMethod(object target, Type inputType)
{
    var @interface = typeof(IMyTest<>).MakeGenericType(inputType);
    if (@interface.IsAssignableFrom(target.GetType()))
    {
        var method = @interface.GetMethod("MyMethod");
        if (method != null)
        {
            Action<object> action = obj =>
            {
                if (obj.GetType().IsAssignableFrom(inputType))
                    method.Invoke(target, new object[] { obj });
            };

            return action;
        }
    }

    return null;
}

还有……

MyClass foo = new MyClass();
Action<object> action = DoCallMyMethod(foo, typeof(int));
action(47);         // MyMethod(int) is called.
action("...");      // Nothing happens.

现在您有一个Action<object>，它仅在传递整数时调用MyMethod(int)。