Ein echtes Beispiel für die Verwendung der Schnittstelle im Zusammenhang mit Mehrfachvererbung

Ein gutes Beispiel für eine Schnittstelle ist ein Repository-Muster. Ihre Schnittstelle wird Methoden wie Get, GetAll, Update, Delete usw. definieren. Keine Implementierung, nur Funktionssignaturen.

Dann können Sie eine "konkrete" Implementierung dieser Klasse schreiben, um beispielsweise mit MySQL zu arbeiten. Ihre Benutzeroberfläche sollte jedoch nur auf die Benutzeroberfläche verweisen.

Später, wenn Sie sich entscheiden, zu Microsoft SQL zu wechseln, schreiben Sie eine andere konkrete Implementierung, aber Ihr UI-Code muss sich nicht ändern (viel).

Mehrfachvererbung existiert in C # nicht in dem Sinne, dass Sie nur von einer "konkreten" Klasse erben können; Sie können jedoch beliebig viele Schnittstellen erben (oder "implementieren").

Ich schreibe ein Videospiel. In diesem Videospiel verwende ich verschiedene Kräfte auf Objekte im Spiel. Schubkräfte, Stoßkräfte, Gravitationskräfte. Während sie unterschiedlich berechnet werden, haben sie alle die gleichen Grundelemente. Ich muss eine Update-Funktion aufrufen, die die Kraft auswertet und die Kraft dem Objekt hinzufügt, an das sie angehängt ist.

Also habe ich eine IForce-Schnittstelle erstellt, die eine Update-Funktion für ihre Signatur hat. Alle meine Kräfte implementieren diese Schnittstelle:

Hier ist eine Beispielimplementierung.

Die Update-Funktion hat eine vereinfachte Aktualisierung der Federkraft, um das Verständnis zu erleichtern.

Dies hilft auf verschiedene Arten.

Ich kann die Berechnung einer Kraft vollständig ändern, ohne andere Teile meines Codes zu beeinflussen. Ich mache das die ganze Zeit. In diesem Sinne ist es für mich ganz leicht, neue Kräfte hinzuzufügen. Solange es die IForce-Schnittstelle implementiert, weiß ich, dass es gut in meinen bestehenden Code passt.

Eine andere Möglichkeit ist die Handhabung einer großen Anzahl von Kräften. Ich habe ein Kraftregister, das eine Liste von IForce hat. Da alle Kräfte diese Schnittstelle implementieren und eine Update-Funktion haben, ist es sehr einfach, alle Kräfte in meinem Spiel zu aktualisieren. Wenn ich die Kraft erstelle, füge ich sie der Liste hinzu. Dann durchlaufe ich die Liste und rufe jede Elementaktualisierungsfunktion auf, ohne mich darum zu kümmern, welche Art von Kraft es ist und alle meine Kräfte aktualisieren.

Ich benutze jeden Tag Schnittstellen in vielen verschiedenen Situationen. Sie sind fantastisch!

Hinweis: Schnittstelle wird verwendet, um die Methoden oder Ereignisse usw. von verschiedenen Klassen um jeden Preis einzuschränken und darauf zuzugreifen. Dies bedeutet, dass wir viele weitere Methoden in jeder Klasse definieren können, aber wenn wir Methoden über Interface aufrufen, wollen wir nur andere als restricted Methoden. Im folgenden Programm kann User1 Read & amp; Schreibe beides, aber Benutzer2 kann schreiben und ausführen. Siehe dieses Programm unten .........

Ausgabe:

Schnittstellen definieren einfach einen Vertrag der öffentlichen Elemente (z. B. Eigenschaften, Methoden, Ereignisse) für Ihr Objekt, nicht für das Verhalten.

AKTUALISIEREN

In "realen Beispielen" verwende ich Schnittstellen mit: - Stückprüfung - GENERICS (z. B. Repository, Gateway, Einstellungen)

Hier ist einer (in Java, aber das ist nicht wichtig, da sie ähnlich sind): In meinem Projekt habe ich eine einfache Schnittstelle erstellt:

Dies ist ein einfacher Ersatz für einige Arten von Anmerkungen. Der nächste Schritt: Ich habe alle Entity-Klassen dazu gebracht, diese Schnittstelle zu implementieren.

Der dritte Schritt besteht darin, einige Syntax-Zucker-ähnliche Methoden zu schreiben:

Dies war nur ein Beispiel.

Das komplexere Beispiel ist etwas wie Validierungsregeln: Sie haben eine Validierungs-Engine (wahrscheinlich von Ihnen geschrieben) und eine einfache Schnittstelle für die Regel:

Diese Engine erfordert also, dass die Regeln von Ihnen implementiert werden. Und natürlich wird es mehrere Vererbungen geben, da Sie sicher mehr als eine einzige Regel wünschen.

Mehrfachvererbung bedeutet, dass eine Klasse in mehreren Situationen verwendbar ist: [Pseudocode]

Die Idee ist, dass Ihre Circle-Klasse zwei verschiedene Schnittstellen implementiert, die in sehr unterschiedlichen Situationen verwendet werden.

Manchmal ist es einfach zu abstrakt, wenn man sich auf Implementierungsdetails bezieht, um Dinge zu klären. Daher werde ich die naheliegende Erklärung der Schnittstellen liefern, die mich dazu gebracht haben, sie endlich zu knacken.

Eine Schnittstelle ist nur eine Möglichkeit zu deklarieren, dass eine Klasse einige virtuelle Funktionen implementiert und wie diese virtuellen Funktionen in der Klasse der Klasse angeordnet werden sollten vtable . Wenn Sie eine Schnittstelle deklarieren, geben Sie dem Compiler im Wesentlichen eine Beschreibung einer virtuellen Funktionstabelle auf einer höheren Ebene. Wenn Sie eine Schnittstelle implementieren, weisen Sie den Compiler an, dass Sie die Vtable, auf die sich diese Schnittstelle bezieht, in Ihre Klasse aufnehmen möchten.

Der Zweck von Schnittstellen besteht darin, dass Sie eine Klasse, die die Schnittstelle I implementiert, implizit in eine Instanz der Schnittstelle I umwandeln können:

Die einfache Antwort, meiner Meinung nach, und etwas neu zu Schnittstellen selbst ist, dass das Implementieren einer Schnittstelle in einer Klasse im Wesentlichen bedeutet: "Diese Klasse muss die Funktionen (und Parameter) in der Schnittstelle definieren."

Daraus folgt, dass immer, wenn eine bestimmte Klasse die Schnittstelle implementiert, Sie sicher sein können, dass Sie diese Funktionen aufrufen können.

Wenn mehrere Klassen, die ansonsten unterschiedlich sind, dieselbe Schnittstelle implementieren, können Sie sie alle an die Schnittstelle "werfen" und alle Schnittstellenfunktionen aufrufen, die unterschiedliche Auswirkungen haben können, da jede Klasse eine andere Implementierung der Klasse haben kann Funktionen.

Ich habe zum Beispiel ein Programm erstellt, mit dem ein Benutzer vier verschiedene Arten von Karten erstellen kann. Dafür habe ich 4 verschiedene Arten von Generator-Klassen erstellt. Sie alle implementieren jedoch die "IGenerator" -Schnittstelle:

Dies sagt ihnen, mindestens eine "public generateNow (int period)" Funktion zu definieren.

Welcher Generator ich ursprünglich auch hatte, nachdem ich ihn in einen "IGenerator" umgewandelt habe, kann ich "generateNow (4)" darauf nennen. Ich werde nicht sicher sein müssen, welche Art von Generator ich zurückgegeben habe, was im Wesentlichen bedeutet, keine "variable instanceof Class1", "variable instanceof Class2" usw. in einer gigantischen if-Anweisung mehr.

Sehen Sie sich etwas an, das Ihnen vertraut ist - zB eine List-Auflistung in C #. Listen definieren die IList-Schnittstelle und generische Listen definieren die IList-Schnittstelle. IList macht Funktionen wie Hinzufügen, Entfernen verfügbar und die Liste implementiert diese Funktionen. Es gibt auch BindingLists, die IList auf eine etwas andere Art implementieren.

Ich würde auch Head First Design Patterns empfehlen. Die Codebeispiele sind in Java, werden aber leicht in C # übersetzt, und sie werden Sie mit der wirklichen Macht von Schnittstellen und Entwurfsmustern vertraut machen.