Interface C#

Interface, en C#, est un mot-clé qui contient un groupe de méthodes et de propriétés abstraites, qui doivent être implémentées ou utilisées par une classe abstraite ou non abstraite. La définition des méthodes sont des propriétés à l'intérieur d'une interface qui les rend publiques et abstraites par défaut.

En termes les plus simples, une interface est comme un contrat, où chaque membre ou composant inclus dans le corps doit suivre le contrat, il définit ce qui doit être fait. L'interface ne contient aucun champ et est toujours définie par l'utilisation du mot-clé « interface ».

Syntaxe :

La syntaxe commence par le mot-clé interface suivi du nom de l'interface, puis du corps.

interface <name_for_interface>
{
//abstract methods
//abstract properties.
}

Comme vous pouvez le voir, nous avons notre syntaxe standard pour Interface en C#, qui commence par le mot-clé 'interface' puis le nom de l'interface, puis les méthodes et propriétés abstraites à l'intérieur du corps. En C#, plusieurs interfaces peuvent être implémentées et utilisées, au sein d’une classe ou d’une structure. Ces interfaces peuvent contenir diverses méthodes, indexeurs, propriétés ainsi que des événements en tant que membres.

Pourquoi avons-nous besoin de l'interface C# ?

En gros, nous avons compris qu'il n'y a pas de fonctionnalité spécifique à l'intérieur d'une interface, si c'est le cas, alors pourquoi avons-nous besoin d'une interface ?

Quand utiliser Interface ?

• Sécurité : Quand nous devons simplement masquer certaines fonctionnalités et les utiliser plus tard. Il est essentiel de masquer quelques détails tout en n'affichant que les détails importants pour l'utilisateur.
• Héritage multiple : En c#, une classe peut hériter d'une simple classe parent, héritant de toutes ses fonctionnalités. L'héritage multiple n'est pas pris en charge en C# pour la simple raison de ne pas rendre C# complexe. Mais avec l'utilisation d'une interface, plusieurs interfaces peuvent être implémentées dans une seule classe.

L'interface C# comprend généralement les éléments suivants :

1. Déclaration – En C#, une interface est un contrat qui définit un ensemble de signatures de méthode, de propriétés, d'événements ou d'indexeurs. Il ne contient aucune implémentation et sert de modèle auquel les classes doivent adhérer. Les classes qui implémentent une interface doivent fournir des implémentations concrètes pour tous les membres déclarés dans l'interface.
2. Membres – les membres de l'interface sont des méthodes, des propriétés, des événements et des indexeurs déclarés dans une interface. Ils définissent un contrat auquel les classes implémentées doivent adhérer, garantissant un comportement cohérent entre les différentes classes. Les classes d'implémentation doivent fournir des implémentations concrètes pour ces membres, favorisant la cohérence du code et permettant le polymorphisme et la réutilisation du code.
3. Implémentation – Une classe qui implémente une interface doit fournir une implémentation pour tous les membres déclarés dans l'interface. La classe peut spécifier explicitement qu'elle implémente une interface en utilisant la syntaxe : interfaceName. Par exemple:

   public class MyClass : IMyInterface
   {
   public void Method1()
   {
   // Method implementation
   }public string Property1 { get; set; }
   
   public event EventHandler Event1;
   }

4. Héritage multiple : C# prend en charge l'héritage multiple via des interfaces. Une classe peut implémenter plusieurs interfaces, ce qui lui permet d'hériter de plusieurs ensembles de signatures de méthodes sans les complexités associées à l'héritage multiple d'implémentation. Cela permet une plus grande flexibilité dans la conception des classes tout en évitant le problème du diamant inhérent à l'héritage multiple traditionnel.
5. Héritage d'interface : En C#, l'héritage d'interface permet à une interface dérivée d'hériter des signatures de méthode définies dans une ou plusieurs interfaces de base. Une classe implémentant l'interface dérivée doit fournir des implémentations pour toutes les méthodes héritées. Cela permet la création de hiérarchies d'interfaces, favorisant la réutilisation du code et la flexibilité dans la conception des objets.

Exemples d'interface C#

Maintenant que nous avons compris ce qu'est l'interface et sa nécessité. Montrons un exemple simple de code C# avec implémentation d'interface.

Exemple n°1

Le programme implémente l'interface et imprime une instruction simple.

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();
}
}
}

Interprétation du code : En commençant par l'utilisation et l'espace de noms, une interface de base est générée sous la forme d'une SampleInterface qui a une seule méthode dans son corps. Cette méthode à l’intérieur d’une interface n’a pas de corps particulier. Ensuite, nous avons notre nouvelle classe qui doit implémenter l'interface que nous avons créée. Créé avec le mot-clé class suivi du nom de la classe, puis implémentant l'interface avec le symbole deux-points suivi du nom de l'interface. Dans notre classe Int_Example, nous avons notre méthode d'interface créée précédemment, qui était alors sans corps, nous avons maintenant ajouté la simple instruction print, qui dit : « Ceci est un exemple simple d'interface en 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#.”

Example #2

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:

Advantages

Below are some of the advantages given.

• One of the major advantages of Interface in C# is a better alternative to implement multiple inheritances.
• The interface enables the plug-and-play method.
• Complete Abstraction can be achieved by the implementation of Interface.
• Along with making our code easy to maintain, concept loose coupling can be achieved.

Conclusion

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!