How to resolve ambiguous interface method signatures, occuring when multiple generic type arguments are identical

Question

In the example below, is there a way for a method of the implementing class to explicitly tell the compiler which interface member it implements? I know it's possible to resolve ambiguity between interfaces, but here it is within one interface.

interface IFoo<A,B>
{
    void Bar(A a);
    void Bar(B b);
}

class Foo : IFoo<string, string>
{
    public void Bar(string a) { }
    public void Bar(string b) { }  // ambiguous signature
}

Answer 1

I don't think that you can solve that directly by only using one interface because the method signatures may unify for some cases.

If you realy need this feature I think you've to introduce a new interface that will be derived by foo.

public interface IBar<T>
{
    void Bar(T t);
}

public interface IFoo<A, B> : IBar<A>
{
    void Bar(B b);
}

Now you're able to explicitly implement both interfaces:

public class Foo : IFoo<string, string>
{
    void IFoo<string, string>.Bar(string b)
    {
        Console.WriteLine("IFoo<string, string>.Bar: " + b);
    }

    void IBar<string>.Bar(string t)
    {
        Console.WriteLine("IBar<string>.Bar: " + t);
    }
}

But if you want to use it you've to cast your instance to the special interface:

var foo = new Foo();
((IFoo<string, string>)foo).Bar("Hello");
((IBar<string>foo).Bar("World");

This prints as expected:

IFoo<string, string>.Bar: Hello
IBar<string>.Bar: World

Hopefully this will help you. I don't think that there is another way of doing that.

It is possible to implement only one interface explicitly so that you only need to cast if you want to call the other method.