When you implement two interfaces with the same method, how do you know which one is called?

Question

If you have TheMethod() in interfaces I1 and I2, and the following class

class TheClass : I1, I2
{
    void TheMethod()
}

If s

Answer 1

As long as the method signatures are the same, it is perfectly legal for a method to implement the methods of two or more interfaces.

There is no way to know "through which interface" a method is called -- there is no such concept (and it doesn't matter).

Answer 2

If that's how the client code is using the class, it doesn't really matter. If it needs to do something interface specific, it should declare the interface it needs, and assign the class to that e.g.

I1 i = new TheClass()
i.TheMethod();

Of course, using your current implementation TheClass, it doesn't matter if declared i as I1, or I2, as you only have a single implementation.

If you want a separate implementation per interface, then you need to create explicit implementations ...

    void I1.TheMethod()
    {
        Console.WriteLine("I1");
    }

    void I2.TheMethod()
    {
        Console.WriteLine("I2");
    }

But keep in mind, explicit implementations cannot be public. You can implement just one explicitly, and leave the other as the default which can be public.

    void I1.TheMethod()
    {
        Console.WriteLine("I1");
    }

    public void TheMethod()
    {
        Console.WriteLine("Default");
    }

Have a look the msdn article for more details.

Answer 3

You don't use an interface in the sense of calling it. An interface is just a contract defining which methods you can call essentially. You always call the implementation.

Answer 4

The real question is, "Who cares which interface it is using?" Really, it's not "using" the interface at all. It's using the implementation to fulfil the interface.

Answer 5

If you instantiate the class, then you are not using any of the interfaces. If you cast the reference to either interface, then you are using that interface. Example:

TheClass c = new TheClass();
c.TheMethod(); // using the class

I1 i = new TheClass();
i.TheMethod(); // using the I1 interface

As your class is declared, both interfaces will use the same method. You can also specify methods for the class and the separate interfaces:

class TheClass : I1, I2
{
  void TheMethod() {} // used by the class
  void I1.TheMethod() {} // used by the I1 interface
  void I2.TheMethod() {} // used by the I2 interface
}

If you specify only methods for the interfaces, you can't reach the method unless you cast the reference to an interface first:

class TheClass : I1, I2
{
  void I1.TheMethod() {} // used by the I1 interface
  void I2.TheMethod() {} // used by the I2 interface
}

If you specify separate methods for only some interfaces, the other interfaces will use the same implementation as the class:

class TheClass : I1, I2
{
  void TheMethod() {} // used by the class and the I1 interface
  void I2.TheMethod() {} // used by the I2 interface
}

Answer 6

public interface IA
{
   void Sum();
}

public interface IB
{
    void Sum();
}

public class SumC : IA, IB
{
   void IA.Sum()
    {
        Console.WriteLine("IA");
    }

   void IB.Sum()
   {
       Console.WriteLine("IB");
   }
  public void Sum()
   {
       Console.WriteLine("Default");
   }
}

public class MainClass
{
    static void Main()
    {
        IA objIA = new SumC();
        IB objIB = new SumC();
        SumC objC = new SumC();

        objIA.Sum();
        objIB.Sum();
        objC.Sum();

        Console.ReadLine();
    }
}