c# - 当期望是通用接口基类型时如何传递方法参数？

Question

假设我有一个如下定义的接口：

interface IContract
{
    void CommonMethod();
}

然后是继承自该接口的另一个接口，其定义方式为：

interface IContract<T> : IContract where T : EventArgs
{
    event EventHandler<T> CommonEvent;
}

我的具体问题是，给定任何实现IContract 的实例，我如何确定是否也是IContract<T>，如果是，那么IContract<T> 的泛型类型是什么？编码我可能遇到的每种已知类型的IContract<T>。

最终，我将使用此决定来调用以下模式：

void PerformAction<T>(IContract<T> contract) where T : EventArgs
{
    ...
}

Answer 1

由于您需要IContract<T> 的实例，您必须先使用反射来获取泛型类型参数，然后再调用适当的方法：

// results in typeof(EventArgs) or any class deriving from them
Type type = myContract.GetType().GetGenericArguments()[0]; 

现在获取IContract<T> 的通用类型定义并获取适当的方法。

// assuming that MyType is the type holding PerformAction
Type t = typeof(MyType).MakeGenericType(type); 
var m = t.GetMethod("PerformAction");

如果只有方法 PerforAction 是通用的，而不是 MyType：

// assuming that MyType is the type holding PerformAction
Type t = typeof(MyType); 
var m = t.GetMethod("PerformAction").MakeGenericMethod(type);

现在您应该能够在 IContract 的实例上调用该方法：

var result = m.Invoke(myInstance, new[] { myContract } );

其中myInstance 的类型为MyType。

Answer 2

这是我用过的解决方案：

首先，非常感谢@HimBromBeere 提供了此解决方案的基础。本质上，他发布的是答案，但这里包含的是我如何实现此架构的相关细节。

给定以下接口：

interface IContract
{
    void CommonMethod();
}

interface IContract<T> : IContract where T : EventArgs
{
    event EventHandler<T> CommonEvent;
}

我有一个类，其所有意图和目的声明如下：

abstract class BaseControl
{
    protected void SubscribeToContract<Type>(IContract<Type> contract) 
        where Type : EventArgs
    {
        contract.ContractChanged += 
            delegate(object sender, Type e)
            {
                // Calls this method to perform other actions:
                OnContractChanged(e);
            };
    }

    // Called when IContract<>.ContractChanged is raised:
    protected virtual void OnContractChanged(EventArgs e);
}

class SpecialControl : BaseControl, IContract<SpecialEventArgs>
{
    ...

    protected override OnContractChanged(EventArgs e)
    {
        base.OnContractChanged();
        PerformAction(e);
    }

    ...

    void PerformAction(EventArgs e)
    {
        // We can also now find out if "e" is SpecialEventArgs
        if (e is SpecialEventArgs)
        {
            ...
        }
        ...
    }

   ...      
}

其中方法SubscribeToContract<Type>() 是从BaseControl 继承的受保护成员。这允许派生类实现自己的方法，例如PerformAction()，同时抽象出不必担心处理通用接口的东西（目标）。

在我的类中有一个event，我使用以下语句来确定参数是否实现IContract，这是IContract<> 的基本接口：

if (e.Control is IContract)
{
    // Gets all the IContract<> interfaces e.Control implements:
    var generics = GetIContractGenerics(e.Control.GetType());

    // There might be multiple IContract<> implementations
    // so therefore we need to check them all, even though in
    // practice there will likely only be a single instance:
    foreach (var generic in generics)
    {
        var method = this.GetType().GetMethod(
            "SubscribeToContract", (BindingFlags.Instance | BindingFlags.NonPublic));
        method = method.MakeGenericMethod(generic);
        var result = method.Invoke(this, new[] { e.Control });
    }
}

在我的情况下，需要设置 (BindingFlags.Instance | BindingFlags.NonPublic) 才能让 GetMethod() 函数返回 SubscribeToContract<Type>() 方法。

其中方法GetIContractGenerics()是使用this StackOverflow post中描述的方法创建的：

protected static IEnumerable<Type> GetIContractGenerics(Type type)
{
    return
        from implementation in type.GetInterfaces()
        where implementation.IsGenericType
        let definition = implementation.GetGenericTypeDefinition()
        where definition == typeof(IContract<>)
        select implementation.GetGenericArguments().First();
}

为方便起见，这个GetIContractGenerics() 静态方法存储在BaseControl 中。

就是这样，一切正常！感谢大家的意见！