Schnittstellen zu implementieren gehört zum grundlegenden Handwerkszeug eines C# Entwicklers. Bei der Frage nach dem Unterschied zwischen impliziten und expliziten Schnittstellen kommt aber bereits so mancher Entwickler ins Grübeln. In diesem Artikel möchte ich Ihnen deshalb die beiden Möglichkeiten der Schnittstellenimplementierung aufzeigen und anhand kurzer Beispiele erläutern.
Implizite Schnittstellenimplementierung
Schnittstellen werden üblicherweise implizit implementiert. Die Methoden der Schnittstelle stehen dadurch direkt in der Klasse zur Verfügung. Das folgende Beispiel zeigt diesen Standardfall.
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Foo foo = new Foo();
6
7 foo.DoSomething();
8
9 Console.ReadKey();
10 }
11 }
12
13 public interface IFoo
14 {
15 void DoSomething();
16 }
17
18 public class Foo : IFoo
19 {
20 public void DoSomething()
21 {
22 Console.WriteLine("Foo::DoSomething()");
23 }
24 }
Was aber passiert wenn die Klasse von zwei Schnittstellen erbt welche die gleiche Funktionssignatur enthalten? Der nachfolgende Quellcode zeigt ein entsprechendes Beispiel.
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Foo foo = new Foo();
6
7 foo.DoSomething();
8
9 Console.ReadKey();
10 }
11 }
12
13 public interface IFoo
14 {
15 void DoSomething();
16 }
17
18 public interface IBar
19 {
20 void DoSomething();
21 }
22
23 public class Foo : IFoo, IBar
24 {
25 public void DoSomething()
26 {
27 Console.WriteLine("Foo::DoSomething()");
28 }
29 }
Die Schnittstellen IFoo und IBar erfordern beide die Implementierung der Funktion DoSomething(). Die gezeigt implizite Implementierung resultiert in einer Funktion die beiden Schnittstellen gerecht wird. Die ist zulässig und kann auch so gewollt sein. Andererseits gibt es aber auch Anwendungsfälle in denen die beiden Schnittstellen zwar die gleiche Methodensignatur enthalten aber dabei ist nicht die gleiche Funktionalität gefordert. Eine getrennte Implementierung von zwei unabhängigen Methoden ist somit nötig. In diesem Fall kann eine explizite Schnittstellenimplementierung erfolgen.
Explizite Schnittstellenimplementierung
Bei der Implementierung mehrerer Schnittstellen kann es zu Überschneidungen kommen. in diesem Fall können beide Schnittstellen explizit implementiert werden. Die Syntax unterscheidet sich dabei nur minimal von der impliziten Version. Einerseits entfällt der Zugriffsmodifizierer und andererseits wird der Schnittstellenbezeichner vorangestellt. Ein Aufruf der implementierten Schnittstellenmethoden erfolgt, indem die Objektinstanz explizit auf die jeweilige Schnittstelle konvertiert wird. Der nachfolgende Quellcode zeigt das entsprechend angepasste Beispiel.
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Foo foo = new Foo();
6
7 //foo.DoSomething(); //error
8
9 (foo as IFoo).DoSomething();
10 (foo as IBar).DoSomething();
11
12 Console.ReadKey();
13 }
14 }
15
16 public interface IFoo
17 {
18 void DoSomething();
19 }
20
21 public interface IBar
22 {
23 void DoSomething();
24 }
25
26 public class Foo : IFoo, IBar
27 {
28 void IFoo.DoSomething()
29 {
30 Console.WriteLine("IFoo::DoSomething()");
31 }
32
33 void IBar.DoSomething()
34 {
35 Console.WriteLine("IBar::DoSomething()");
36 }
37 }
Die Anwendung erzeugt die folgende Ausgabe:
IFoo::DoSomething()
IBar::DoSomething()
In den Zeilen 28 und 33 sehen Sie die entsprechende Syntax der expliziten Schnittstellenimplementierung. In den Zeilen 9 und 10 werden die Methoden aufgerufen. Dazu wird die Objektinstanz in die entsprechende Schnittstelle konvertiert. Wenn Sie den Aufruf in Zeile 7 aktivieren, dann wird ein Fehler gemeldet, da die Klasse die Methode nicht implizit Implementiert.
Implizite und explizite Schnittstellenimplementierung
Die implizite und explizite Implementierungsform lässt sich auch gemeinsam verwenden. Eine mehrfach geforderte Schnittstellenmethode könnte zum Beispiel implizit erstellt werden um die Klasse dadurch mit einem entsprechenden Standardverhalten auszustatten. Zusätzlich können explizite Methoden erstellt werden, welche schnittstellenspezifische Abweichungen vom Standardverhalten umsetzen. Der nachfolgende Quellcode zeigt die entsprechende Erweiterung der Beispielanwendung.
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Foo foo = new Foo();
6
7 foo.DoSomething();
8
9 (foo as IFoo).DoSomething();
10 (foo as IBar).DoSomething();
11
12 Console.ReadKey();
13 }
14 }
15
16 public interface IFoo
17 {
18 void DoSomething();
19 }
20
21 public interface IBar
22 {
23 void DoSomething();
24 }
25
26 public class Foo : IFoo, IBar
27 {
28 public void DoSomething()
29 {
30 Console.WriteLine("Foo::DoSomething()");
31 }
32
33 void IFoo.DoSomething()
34 {
35 Console.WriteLine("IFoo::DoSomething()");
36 }
37
38 void IBar.DoSomething()
39 {
40 Console.WriteLine("IBar::DoSomething()");
41 }
42 }
Die Anwendung erzeugt die folgende Ausgabe:
Foo::DoSomething()
IFoo::DoSomething()
IBar::DoSomething()
Fazit
Explizite Schnittstellenimplementierungen lassen sich hauptsächlich dann einsetzen wenn mehrere Schnittstellen genutzt werden und dabei Überschneidungen auftreten, beispielsweise durch gleiche Methodensignaturen. Mittels einer expliziten Implementierung der Schnittstellen lassen sich diese Überschneidungen auflösen. Somit können die Methoden je Schnittstelle erzeugt werden. Dies erlaubt die Programmierung und Verwendung mehrere Methoden mit gleicher Signatur.
coders corner 