Si une classe implémente deux interfaces qui contiennent un membre avec la même signature, l'implémentation de ce membre sur la classe fera en sorte que les deux interfaces utilisent ce membre comme leur implémentation. Par exemple :

interface IControl
{
    void Paint();
}
interface ISurface
{
    void Paint();
}
class SampleClass : IControl, ISurface
{
    // Both ISurface.Paint and IControl.Paint call this method.
    public void Paint()
    {
    }
}

Toutefois, si les deux membres d'interface n'exécutent pas la même fonction, cela peut engendrer une implémentation incorrecte d'une interface ou des deux. Il est possible d'implémenter un membre d'interface explicitement, en créant un membre de classe qui n'est appelé qu'à travers l'interface et qui est spécifique à cette interface. Pour ce faire, vous devez nommer le membre de classe avec le nom de l'interface et un point. Par exemple :

public class SampleClass : IControl, ISurface
{
    void IControl.Paint()
    {
        System.Console.WriteLine("IControl.Paint");
    }
    void ISurface.Paint()
    {
        System.Console.WriteLine("ISurface.Paint");
    }
}

Le membre de classe IControl.Paint est uniquement disponible à travers l'interface IControl, et ISurface.Paint est uniquement disponible à travers ISurface. Les deux implémentations de méthode sont distinctes, et aucune n'est directement disponible sur la classe. Par exemple :

SampleClass obj = new SampleClass();
//obj.Paint();  // Compiler error.

IControl c = (IControl)obj;
c.Paint();  // Calls IControl.Paint on SampleClass.

ISurface s = (ISurface)obj;
s.Paint(); // Calls ISurface.Paint on SampleClass.

L'implémentation explicite est également utilisée pour résoudre les cas où deux interfaces déclarent chacune des membres différents du même nom, comme une propriété et une méthode :

interface ILeft
{
    int P { get;}
}
interface IRight
{
    int P();
}

Pour implémenter les deux interfaces, une classe doit utiliser l'implémentation explicite pour la propriété P, la méthode P, ou les deux, pour éviter une erreur du compilateur. Par exemple :

class Middle : ILeft, IRight
{
    public int P() { return 0; }
    int ILeft.P { get { return 0; } }
}