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. In diesem ersten Beispiel werden die Typen definiert:This first sample defines the types:

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

Im folgenden Beispiel werden die Methoden aufgerufen:The following sample calls the methods:

SampleClass sample = new SampleClass();
IControl control = sample;
ISurface surface = sample;

// The following lines all call the same method.
sample.Paint();
control.Paint();
surface.Paint();
// Output:
// Paint method in SampleClass
// Paint method in SampleClass
// Paint method in SampleClass

Wenn zwei Schnittstellenmember nicht dieselbe Funktion durchführen, führt dies zu einer fehlerhaften Implementierung von einer oder beiden Schnittstellen.When two interface members don't perform the same function, it leads to an incorrect implementation of one or both of the interfaces. Ein Schnittstellenmember kann explizit implementiert werden. Hierzu wird ein Klassenmember erstellt, der nur über die Schnittstelle aufgerufen wird und spezifisch auf diese Schnittstelle ausgelegt ist.It's possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. Benennen Sie den Klassenmember hierzu mit dem Namen der Schnittstelle und einem Punkt.Name 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 voneinander getrennt, und sie sind nicht direkt in der Klasse verfügbar.Both method implementations are separate, and neither are 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 = obj;
c.Paint();  // Calls IControl.Paint on SampleClass.

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

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

Die 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. Zum Implementieren beider Schnittstellen muss eine Klasse die explizite Implementierung für die Eigenschaft P, die Methode P oder beide verwenden, um einen Compilerfehler zu vermeiden.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:

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

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

Ab C# 8.0 können Sie eine Implementierung für in einer Schnittstelle deklarierte Mitglieder definieren.Beginning with C# 8.0, you can define an implementation for members declared in an interface. Wenn eine Klasse eine Methodenimplementierung von einer Schnittstelle erbt, ist diese Methode nur über einen Verweis des Schnittstellentyps zugänglich.If a class inherits a method implementation from an interface, that method is only accessible through a reference of the interface type. Der geerbte Member wird nicht als Teil der öffentlichen Schnittstelle angezeigt.The inherited member doesn't appear as part of the public interface. Im folgenden Beispiel wird eine Standardimplementierung für eine Schnittstellenmethode definiert:The following sample defines a default implementation for an interface method:

public interface IControl
{
    void Paint() => Console.WriteLine("Default Paint method");
}
public class SampleClass : IControl
{
    // Paint() is inherited from IControl.
}

Im folgenden Beispiel wird die Standardimplementierung aufgerufen:The following sample invokes the default implementation:

var sample = new SampleClass();
//sample.Paint();// "Paint" isn't accessible.
var control = sample as IControl;
control.Paint();

Alle Klassen, die die IControl-Schnittstelle implementieren, können die Standardmethode Paint überschreiben: entweder als öffentliche Methode oder als explizite Schnittstellenimplementierung.Any class that implements the IControl interface can override the default Paint method, either as a public method, or as an explicit interface implementation.

Weitere InformationenSee also