Implémentation d'interface explicite (Guide de programmation C#)

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. Dans l'exemple suivant, tous les appels à Paint appeler la même méthode.

class Test 
{
    static void Main()
    {
        SampleClass sc = new SampleClass();
        IControl ctrl = (IControl)sc;
        ISurface srfc = (ISurface)sc;

        // The following lines all call the same method.
        sc.Paint();
        ctrl.Paint();
        srfc.Paint();
    }
}


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

// Output: 
// Paint method in SampleClass 
// Paint method in SampleClass 
// Paint method in SampleClass

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 :

// Call the Paint methods from Main.

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. 

// Output: 
// IControl.Paint 
// ISurface.Paint

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

Voir aussi

Référence

Classes et structs (Guide de programmation C#)

Interfaces (Guide de programmation C#)

Héritage (Guide de programmation C#)

Concepts

Guide de programmation C#