通用方法：如何使用最专业的方法进行强制

Question

我在接口IInterface定义了通用方法Use<T> 。 我尝试实现该接口的实现，其中Use<T>方法的具体实现取决于实际的类型T ，并且我想始终调用最专门的方法。 但这不起作用：

    interface IInterface { void Use<T>(T other) where T : IInterface; }
    interface IChildInterface : IInterface { }
    class ImplementsIInterface : IInterface
    {
        public void Use<T>(T other) where T : IInterface
        {
            Debug.WriteLine("ImplementsInterface.Use(IInterface)");
        }
    }
    class ImplementsChildInterface : IChildInterface
    {
        public void Use<T>(IChildInterface other) where T : IInterface
        { // idea: if other is IChildInterface, use this method
            Debug.WriteLine("ImplementsChildInterface.Use(IChildInterface)");
        }

        public void Use<T>(T other) where T : IInterface
        { // idea: if above method is not applicable, use this method
            Debug.WriteLine("ImplementsChildInterface.Use(IInterface)");
        }
    }

这是我的主要方法：

    public static void Main()
    {
        IChildInterface childinterf = new ImplementsChildInterface();

        childinterf.Use(new ImplementsChildInterface()); // outputs "ImplementsChildInterface.Use(IInterface)"
                                                         // but should output "ImplementsChildInterface.Use(IChildInterface)"

        childinterf.Use(new ImplementsIInterface());     // outputs "ImplementsChildInterface.Use(IInterface)"
    }

可以调用带有IChildInterface参数的方法，尽管它应该被调用。

有没有办法使这项工作？ 还是我的方法根本上是错误的？

请注意， IInterface仅具有一个方法定义是必要的。 我可以随时扩大接口层次结构（从而增加我可以在实现类中提供的实现数量），但是这不应该导致需要在IInterface添加更多方法定义。 否则，将失去使用接口的全部要点（即要灵活）。

---

到目前为止，我得到的答案都涉及强制转换的需要。 这也是我不想做的事情，因为这会使整个设置无用。 让我解释一下我要实现的目标的更广阔的前景：

假设我们创建了一个IInterface实例（例如： IInterface foo = new ImplementsChildInterface(); ）。 它会以某种方式运行，但始终会以相同的方式运行-无论我们将其视为IInterface ， IChildInterface还是ImplementsChildInterface 。 因为，如果我们在其上调用某种方法，编译器（或运行时？我不知道）将检查它的真正类型，并运行该类型中定义的方法。

现在想象一下，我们有IInterface两个实例i1和i2 。 它们仍然是IInterface具体实现，因此无论我们通过哪种眼镜IInterface ，它们都有具体的行为。

因此，当我运行i1.Use(i2) ，编译器（或运行时？）应该能够找出i1和i2真正是什么，并运行相应的方法。 像这样：

1. i1有哪种类型？ ImplementsChildInterface ，好吧，那我来看一下那里的方法。
2. i2有哪种类型？ ImplementsIInterface ，好的，接下来让我们看看是否存在方法Use(ImplementsIInterface ...) 。 没有，但是也许有一个后备？ ImplementsIInterface是IInterface ，因此让我们看看是否存在方法Use(IInterface ...) 。 是的，它存在，所以让我们称之为它！

Answer 1

IInterface和IChildInterface都没有IChildInterface Use<T>(IChildInterface other)成员，而只有Use<T>(T other)定义了成员。

另一侧的类ImplementsChildInterface具有方法Use<T>(IChildInterface other) 。 当你声明childInterf类型的参考IChildInterface你不容访问构件，但那些unly在接口中定义。 因此，您应该转换为实际的类，以便访问接受IChildInterface实例的IChildInterface 。 但是即使那样，仍使用通用实现。 因此，您还应该将参数转换为IchildInterface ：

ImplementsChildInterfacechildinterf = new ImplementsChildInterface();
childinterf.Use(((IChildInterface)new ImplementsChildInterface()); 
childinterf.Use(new ImplementsIInterface());

此外，由于您没有在更专业的方法中使用通用类型参数，因此您也可以忽略它：

class ImplementsChildInterface : IChildInterface
{
    public void Use(IChildInterface other)
    { // idea: if other is IChildInterface, use this method
        Debug.WriteLine("ImplementsChildInterface.Use(IChildInterface)");
    }

    public void Use<T>(T other) where T : IInterface
    { // idea: if above method is not applicable, use this method
        Debug.WriteLine("ImplementsChildInterface.Use(IInterface)");
    }
}

另外，您也可以在IChildInterface添加一个方法：

void Use<T>(IChildInterface other) where T : IChildInterface;

现在您可以使用

IChildInterface childinterf = new ImplementsChildInterface();
childinterf.Use<IChildInterface>(new ImplementsChildInterface()); // outputs "ImplementsChildInterface.Use(IInterface)"

这将打印所需的输出。