Drei Schnittstellenimplementierungsmethoden in .NET

Im Allgemeinen bietet .NET drei verschiedene Schnittstellenimplementierungsmethoden, nämlich implizite Schnittstellenimplementierung, explizite Schnittstellenimplementierung und gemischte Schnittstellenimplementierung. Jede dieser drei Methoden hat ihre eigenen Eigenschaften.

Schauen wir uns zunächst die implizite Schnittstellenimplementierung an. Dies ist wahrscheinlich die Schnittstellenimplementierung, die wir am häufigsten verwenden, da die implizite Schnittstellenimplementierung die Standardmethode für die Schnittstellenimplementierung von .NET ist. Schauen wir uns ein Beispiel einer impliziten Schnittstellenimplementierung an:

using System;
internal class MyClass
{
public void SomeMethod()
{
// Utilization Declare a Myinplement Objekt mit der Schnittstelle
IMyInterface iObj = new MyInplement();
iObj.MethodA();
// Deklarieren Sie ein Myinplement-Objekt mit der Klassenmethode
MyInplement obj = new MyInplement() ;
obj.MethodB();
}
}
public class MyInplement : IMyInterface
{
#region IMyInterface Members
///

/// Verwenden Sie die implizite Schnittstellenimplementierung, um Methoden in der Schnittstelle zu implementieren
///

public void MethodA()
{
Console.WriteLine("a");
}
///

/// Implizite Schnittstellenimplementierung verwenden, um Methoden in der Schnittstelle zu implementieren
///

public void MethodB()
{
Console.WriteLine("B");
}
#endregion
}
public interface IMyInterface
{
void MethodA();
void MethodB();
}

Der obige Code ist sehr einfach. Wir deklarieren eine Schnittstelle und verwenden dann die MyImplement-Klasse, um die Schnittstelle zu implementieren. Bei der Implementierung der Schnittstelle haben wir uns für die implizite Schnittstellenimplementierung entschieden, das heißt, wir haben vor der in der Schnittstelle definierten Methodensignatur einen Modifikator hinzugefügt, um die Signatur der Implementierungsmethode zu definieren, z. B. public void MethodB(). Diese implizite Schnittstellenimplementierung ist sehr einfach zu verwenden. Ein Nachteil besteht jedoch darin, dass Kunden Methoden direkt in der Implementierungsklasse aufrufen können (dh das Objekt über MyInplement obj = new MyInplement () deklarieren), anstatt Methoden über die Schnittstelle aufzurufen Die Implementierungsklasse (dh das Deklarieren von Objekten über IMyInterface iObj = new MyInplement ();) erhöht zweifellos die Kopplung des Codes und verstößt gegen die Prinzipien der schnittstellenorientierten Programmierung. Wie können wir also verhindern, dass Kunden die Implementierungsklasse direkt aufrufen? Die explizite Schnittstellenimplementierung, die wir uns weiter unten ansehen werden, reicht aus.

Explizite Schnittstellenimplementierung bedeutet, dass die Implementierungsklasse bei der Implementierung der Schnittstellenmethode den Stil „Schnittstellenname. Methodenname“ verwendet, um den Methodennamen in der Signatur der Methode zu definieren Es ist nicht zulässig, einen Modifikator zu haben, da alle von expliziten Schnittstellen implementierten Methoden privat sind. Dies ist in .NET streng festgelegt, um zu verhindern, dass Kunden die Implementierungsklasse direkt aufrufen. Schauen wir uns ein Beispiel einer expliziten Schnittstellenimplementierung an:

using System;
internal class MyClass
{
public void SomeMethod()
{
// Using interface Declare a Myinplement-Objekt mit
IMyInterface iObj = new MyInplement();
iObj.MethodA();
// Beim Deklarieren eines Myinplement-Objekts mithilfe einer Klassenmethode wird ein Fehler gemeldet, da die MethodA-Methode von MyImplement privat ist
MyInplement obj = new MyInplement();
obj.MethodB();
}
}
public class MyInplement : IMyInterface
{
#region IMyInterface Members
// /

/// Verwenden Sie die explizite Schnittstellenimplementierung, um Methoden in der Schnittstelle zu implementieren
///

void IMyInterface.MethodA()
{
Console. WriteLine("a");
}
///

/// Verwenden Sie eine explizite Schnittstellenimplementierung, um Methoden in der Schnittstelle zu implementieren
/// Es wird ein Fehler gemeldet Modifikatoren sind in expliziten Schnittstellenimplementierungen nicht zulässig
///

public void IMyInterface.MethodB()
{
Console.WriteLine("B"); 🎜>#endregion
}
public interface IMyInterface
{
void MethodA();
void MethodB();
}

oben Es gibt zwei Stellen in Der Code, in dem Fehler gemeldet werden, liegt daran, dass wir gegen die Einschränkungen der expliziten Schnittstellenimplementierung verstoßen haben, in der die Fehler gemeldet wurden.

Schließlich schauen wir uns die Hybridschnittstellenimplementierung an, bei der implizite Schnittstellenimplementierung und explizite Schnittstellenimplementierung zusammen verwendet werden:

unter Verwendung der internen Klasse System;

MyClass

{
public void SomeMethod()
{
// Verwenden Sie die Schnittstelle, um ein Myinplement-Objekt zu deklarieren
IMyInterface iObj = new MyInplement();
iObj.MethodA();
// Verwenden Sie die Klassenmethode, um ein Myinplement-Objekt zu deklarieren. Es wird kein Fehler gemeldet, da die Methode MethodA von MyImplement öffentlich ist.
MyInplement obj = new MyInplement();
obj MethodB();
}
}
public class MyInplement : IMyInterface
{
#region IMyInterface Members
///

/// Explizite Schnittstellenimplementierungsmethode verwenden, um die Methoden zu implementieren in der Schnittstelle
///

void IMyInterface.MethodA()
{
Console.WriteLine("a");
}
/// < ;summary>
/// Implizite Schnittstellenimplementierung verwenden, um Methoden in der Schnittstelle zu implementieren
///
public void MethodB()
{
Console.WriteLine(" B");
}
#endregion
}
public interface IMyInterface
{
void MethodA();
void MethodB();
}

위 코드에서는 MehtodB 구현을 암시적 인터페이스 구현으로 변경하여 MyImplement.Method 수정자가 공개되고 코드에 오류가 없도록 했습니다.