多次实现协变接口：这种行为是否正确定义？

Question

Given the following covariant generic interface

public interface IContainer<out T>
{
    T Value { get; }
}

We can create a class that implements this interface multiple times for multiple generic types. In the scenario I'm interested about, these generic types share a common base type.

public interface IPrint
{
    void Print();
}
public class PrintA : IPrint
{
    public void Print()
    {
        Console.WriteLine("A");
    }
}
public class PrintB : IPrint
{
    public void Print()
    {
        Console.WriteLine("B");
    }
}

public class SuperContainer : IContainer<PrintA>, IContainer<PrintB>
{
    PrintA IContainer<PrintA>.Value => new PrintA();
    PrintB IContainer<PrintB>.Value => new PrintB();
}

Now things get interesting when using this class through a reference of type IContainer<IPrint> .

public static void Main(string[] args)
{
    IContainer<IPrint> container = new SuperContainer();
    container.Value.Print();
}

This compiles and runs without issue and prints "A". What I've found in the spec :

The implementation of a particular interface member IM, where I is the interface in which the member M is declared, is determined by examining each class or struct S, starting with C and repeating for each successive base class of C, until a match is located:

• If S contains a declaration of an explicit interface member implementation that matches I and M, then this member is the implementation of IM
• Otherwise, if S contains a declaration of a non-static public member that matches M, then this member is the implementation of IM

The first bullet point appears to be relevant, because the interface implementations are explicit. However, it doesn't say anything about which implementation is selected when there are multiple candidates.

It gets even more interesting if we use a public poperty for the IContainer<PrintA> implementation:

public class SuperContainer : IContainer<PrintA>, IContainer<PrintB>
{
    public PrintA Value => new PrintA();
    PrintB IContainer<PrintB>.Value => new PrintB();
}

Now, according to above spec, because there is an explicit interface implementation through IContainer<PrintB> , I would expect this to print "B". However, it is instead using the public property and still printing "A".

Similarly, if instead I implement IContainer<PrintA> explicitely and IContainer<PrintB> through public property, it still prints "A".

It appears that the only thing the output depends on is the order in which the interfaces are declared. If I change the declaration to

public class SuperContainer : IContainer<PrintB>, IContainer<PrintA>

everything prints "B"!

Which part of the spec defines this behavior, if it is properly defined at all?

Answer 1

I'm unable to find it in the specification, but what you're seeing is expected. IContainer<PrintA> and IContainer<PrintB> have different Fully Qualified Names (unable to find spec on how this FQN is formed) and so the compiler recognizes SuperContainer as an implementing class of two different interfaces, each having a void Print(); method.

So, we have two different interfaces each containing a method with the same signature. As you linked in the spec (13.4.2) the implementation of Print() is chosen first by looking at IContainer<PrintA> , looking for a proper mapping, and then looking at IContainer<PrintB> .

Since a proper mapping was found in IContainer<PrintA> , IContainer<PrintA>.Print() is used in SuperContainer 's implimentation of IContainer<PrintB> .

From that same spec (located at the very bottom):

The members of a base class participate in interface mapping. In the example

interface Interface1
{
   void F();
}
class Class1
{
   public void F() {}
   public void G() {}
}
class Class2: Class1, Interface1
{
   new public void G() {}
}

the method F in Class1 is used in Class2's implementation of Interface1.

So in the end, yes the order is determining which Print() method is called.