当您使用相同的方法实现两个接口时，您如何知道调用了哪个接口

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

如果这就是客户端代码使用类的方式，那并不重要。如果它需要做一些特定于接口的事情，它应该声明它需要的接口，并将类分配给该接口，例如

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

当然，使用您当前的实现TheClass，是否将i声明为 I1 或 I2 并不重要，因为您只有一个实现。

如果您希望每个接口都有单独的实现，则需要创建显式实现...

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

但请记住，显式实现不能公开。您可以只显式实现一个，并将另一个保留为可以公开的默认值。

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

有关更多详细信息，请查看 msdn 文章。

如果两个方法都是公共的，那么无论在哪个接口上调用它，都将调用相同的方法。 如果需要更精细，则需要使用显式接口实现：

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

用法可能如下所示：

TheClass theClass = new TheClass();
I1 i1 = theClass;
I2 i2 = theClass;
i1.TheMethod();  // (calls the first one)
i2.TheMethod();  // (calls the other one)

要记住的一件事是，如果将两个实现都显式化，您将无法再对声明为 TheClass 的变量调用 TheMethod：

theClass.TheMethod();   // This would fail since the method can only be called on the interface

当然，如果您愿意，您可以只显式使用其中一个实现，并使另一个实现保持公开，在这种情况下，对TheClass调用将调用公共版本。

你不使用调用接口的意义上的接口。接口只是一个协定，定义了你基本上可以调用哪些方法。您始终调用实现。

如果实例化类，则不使用任何接口。如果强制转换对任一接口的引用，则正在使用该接口。例：

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

声明类时，两个接口将使用相同的方法。您还可以为类和单独的接口指定方法：

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
}

如果仅为接口指定方法，则无法访问该方法，除非先强制转换为对接口的引用：

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

如果仅为某些接口指定单独的方法，则其他接口将使用与类相同的实现：

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

只要方法签名相同，一个方法实现两个或多个接口的方法就是完全合法的。

没有办法知道方法"通过哪个接口"被调用 - 没有这样的概念（这并不重要）。

真正的问题是，"谁在乎它使用的是哪个界面？ 真的，它根本没有"使用"界面。 它使用实现来实现接口。

这无关紧要。强制转换为任何接口都将导致调用该方法，但由于接口不能包含代码，因此不能从中继承行为。

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();
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DesignPattern
{
    interface IEmployee
    {
        void show();
    }
    interface IContarctEmployee
    {
        void show();
    }
    class Employee: IEmployee, IContarctEmployee
    {
       void IEmployee.show()
        {
            Console.WriteLine("Show Method is calling for Employee");
        }
        void IContarctEmployee.show()
        {
            Console.WriteLine("Show Method is calling for contract Employee");
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            IEmployee cmp = new Employee();
            IContarctEmployee ice = new Employee();
            cmp.show();
            ice.show();
        }
    }
}