Heim >Backend-Entwicklung >C#.Net-Tutorial >C#-Schnittstelle
Schnittstelle ist in C# ein Schlüsselwort, das eine Gruppe abstrakter Methoden und Eigenschaften enthält, die von einer abstrakten oder nicht abstrakten Klasse implementiert oder verwendet werden sollen. Bei der Definition der Methoden handelt es sich um Eigenschaften innerhalb einer Schnittstelle, die sie standardmäßig öffentlich und abstrakt macht.
Im einfachsten Sinne ist eine Schnittstelle wie ein Vertrag, bei dem jedes im Körper enthaltene Mitglied oder jede Komponente dem Vertrag folgen muss. Er definiert, was getan werden muss. Die Schnittstelle enthält keine Felder und wird immer durch die Verwendung des Schlüsselworts „Schnittstelle“ definiert.
Syntax:
Die Syntax beginnt mit dem Schlüsselwort „interface“, gefolgt vom Namen der Schnittstelle und dann dem Text.
interface <name_for_interface> { //abstract methods //abstract properties. }
Wie Sie sehen können, haben wir unsere Standardsyntax für die Schnittstelle in C#, die mit dem Schlüsselwort „interface“ beginnt, dann dem Namen für die Schnittstelle und dann abstrakten Methoden und Eigenschaften innerhalb des Körpers. In C# können mehrere Schnittstellen innerhalb einer Klasse oder Struktur implementiert und verwendet werden. Diese Schnittstellen können verschiedene Methoden, Indexer, Eigenschaften und auch Ereignisse als Mitglieder enthalten.
Grundsätzlich haben wir verstanden, dass es innerhalb einer Schnittstelle keine spezifische Funktionalität gibt. Wenn das so ist, warum brauchen wir dann eine Schnittstelle?
Wann sollte die Schnittstelle verwendet werden?
public class MyClass : IMyInterface { public void Method1() { // Method implementation }public string Property1 { get; set; } public event EventHandler Event1; }
Jetzt haben wir verstanden, was eine Schnittstelle ist und welchen Bedarf sie hat. Lassen Sie uns ein einfaches Beispiel für C#-Code mit Schnittstellenimplementierung demonstrieren.
Das Programm implementiert die Schnittstelle und gibt eine einfache Anweisung aus.
Code:
using System; namespace MyApplication { interface SampleInterface { void InterfaceMethod(); } class Int_Example : SampleInterface { public void InterfaceMethod() { Console.WriteLine("\nThis is simple example of Interface in C#."); } } class Program { static void Main(string[] args) { Int_Example myInterface = new Int_Example(); myInterface.InterfaceMethod(); Console.Read(); } } }
Code-Interpretation: Ausgehend von der Verwendung und dem Namespace wird eine Basisschnittstelle als SampleInterface generiert, die eine einzelne Methode in ihrem Körper hat. Diese Methode innerhalb einer Schnittstelle hat keinen bestimmten Körper. Dann haben wir unsere neue Klasse, die die von uns erstellte Schnittstelle implementieren soll. Erstellt mit dem Schlüsselwort „class“, gefolgt vom Klassennamen, und anschließende Implementierung der Schnittstelle mit Doppelpunkt, gefolgt vom Schnittstellennamen. In unserer Klasse Int_Example haben wir unsere zuvor erstellte Schnittstellenmethode, die bis dahin körperlos war. Jetzt haben wir die einfache print-Anweisung hinzugefügt, die besagt: „Dies ist ein einfaches Beispiel einer Schnittstelle in C#.“
Then begins our mail class, namely Program, with the static void main statement. Inside our main class, we have created a new object for our Int_Example class which inherits interface. The new object is created and to the next line, our method created earlier is called up. Finally, our newly created object will call the earlier created method and the body inside that method will be executed here. With Console.Read(); the program will wait for user input before exiting.
Output:
Upon successful compilation and execution, the program must simply print the statement: “This is a simple example of Interface in C#.”
Arithmetic operations using the interface.
Code:
using System; namespace arth_interface { public interface SampleInterface { void sam_add(int a, int b); void sam_sub(int a, int b); void display(); } class interface_class : SampleInterface { int x, y; public void sam_add(int a, int b) { int m, n; m = a; n = b; x = m + n; } public void sam_sub(int a, int b) { int m, n; m = a; n = b; y = a - b; } public void display() { Console.WriteLine("Added Value is:" + x); Console.WriteLine("Subtracted value is:" + y); } } class arth_interface { static void Main(string[] args) { interface_class obj_interface_class = new interface_class(); int fnumber, snumber; Console.WriteLine("Please Enter 1st Number to perform Addition and Subtraction:"); fnumber = Convert.ToInt16(Console.ReadLine()); Console.WriteLine("Now 2nd Number to perform Addition and Subtraction:"); snumber = Convert.ToInt16(Console.ReadLine()); obj_interface_class.sam_add(fnumber, snumber); obj_interface_class.sam_sub(fnumber, snumber); obj_interface_class.display(); Console.ReadKey(); } } }
Code Interpretation: Similar to our first example, we have used and namespace statements, followed by the interface and its body with methods. We have two basic methods for addition and subtraction with void as return type, two integers inside every method, respectively. Next, we have our class which implements our interface.
We’ve declared two integers and then we have our first method to calculate addition. Here is the operation that needs to be done for addition and the same is for the subtraction. Then we have our display method, which consists of two print statements, printing addition and subtraction values of the numbers passed.
Finally, we have our class with the main method, where we initially created an object for our interface. Then the program prints “Please Enter the 1st Number to perform Addition and Subtraction:”, where the user inputs a first number and the later second number, for the purpose of calculations. With the object created earlier, the program calls the add and sub-methods from the interface and the same operations are done. At last, we have our display method, which displays our results as defined in the display method and ReadKey(); method holds up our program until any key is pressed.
Output:
Below are some of the advantages given.
We have understood what Interface in C# is. The proper syntax for an interface along with an explanation. To wrap it up, Interfaces in C# are a way to fill the emptiness of multiple inheritances in the language. Later we learned why do we actually need the interface in C# followed by the examples to demonstrate the understanding of the interfaces. The first example was to demonstrate simple use of interface while with the second example we implemented arithmetic operations, followed by Code Interpretation and output screenshot.
Das obige ist der detaillierte Inhalt vonC#-Schnittstelle. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!