Explizite Schnittstellenimplementierung (C#-Programmierhandbuch)Explicit Interface Implementation (C# Programming Guide)

Wenn eine Klasse zwei Schnittstellen implementiert, die einen Member mit derselben Signatur enthalten, bewirkt die Implementierung dieses Members in der Klasse, dass beide Schnittstellen diesen Member als ihre Implementierung verwenden.If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. Im folgenden Beispiel rufen alle Aufrufe von Paint dieselbe Methode auf.In the following example, all the calls to Paint invoke the same method.

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

Falls die beiden Schnittstellen-Member jedoch nicht dieselbe Funktion erfüllen, kann dies zu einer falschen Implementierung von einer oder beiden Schnittstellen führen.If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. Es ist möglich, einen Schnittstellenmember explizit zu implementieren, also einen Klassenmember zu erstellen, der nur über die Schnittstelle aufgerufen wird und für diese Schnittstelle spezifisch ist.It is possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. Dazu benennt man den Klassenmember mit dem Namen der Schnittstelle und einem Punkt.This is accomplished by naming the class member with the name of the interface and a period. Zum Beispiel:For example:

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

Der Klassenmember IControl.Paint ist nur über die Schnittstelle IControl verfügbar, und ISurface.Paint ist nur über ISurface verfügbar.The class member IControl.Paint is only available through the IControl interface, and ISurface.Paint is only available through ISurface. Beide Methodenimplementierungen sind getrennt, und keine ist direkt in der Klasse verfügbar.Both method implementations are separate, and neither is available directly on the class. Zum Beispiel:For example:

// 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

Explizite Implementierung wird auch zum Lösen von Konflikten verwendet, bei denen zwei Schnittstellen verschiedene Member mit demselben Namen deklarieren, z.B. eine Eigenschaft und eine Methode:Explicit implementation is also used to resolve cases where two interfaces each declare different members of the same name such as a property and a method:

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

Um beide Schnittstellen zu implementieren, muss eine Klasse zur Vermeidung eines Compilerfehlers die explizite Implementierung entweder für Eigenschaft P, für Methode P oder für beide verwenden.To implement both interfaces, a class has to use explicit implementation either for the property P, or the method P, or both, to avoid a compiler error. Zum Beispiel:For example:

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

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Klassen und StrukturenClasses and Structs
SchnittstellenInterfaces
VererbungInheritance