Qu'est-ce que l'interface en C# avec exemple

⚡ Résumé intelligent

Une interface en C# définit une interfacetracL'attribut `t` spécifie les méthodes et propriétés qu'une classe doit implémenter, sans fournir le code lui-même. La classe d'implémentation fournit le comportement concret, permettant un faible couplage et l'héritage multiple entre types non liés.

  • 🔗 Avectract: Une interface déclare les signatures des méthodes et des propriétés que chaque classe implémentant l'interface doit définir.
  • ✅ Aucune implémentation : Une interface ne contient que des déclarations, c'est donc la classe qui écrit le code de la méthode proprement dite.
  • (I.e. Mot-clé: Le mot-clé `interface` crée le type, et une classe utilise deux points pour l'implémenter.
  • 🔀 Interfaces multiples : Une seule classe peut implémenter plusieurs interfaces, ce qui confère à C# une forme d'héritage multiple.
  • (I.e. Interface vs ABStracclasse t : Les interfaces définissent uniquement le comportement, tandis que les interfaces absoluestracLes classes t peuvent également contenir un état et du code partagés.
  • 🤖 Aide à l'IA : GitHub Copilot fournit des interfaces et des implémentations, et les pipelines ML.NET s'appuient sur des transformateurs basés sur des interfaces.tracts.

Interface en C#

Qu'est-ce qu'Interface en C# ?

An Interface En C#, une classe est utilisée pour définir une interface.tracL'interface définit les fonctionnalités qu'une classe doit fournir à une application. Elle définit les opérations qu'une classe peut effectuer et déclare ses propriétés et méthodes. Il appartient à la classe de définir précisément le comportement de chaque méthode.

Regardons un exemple d'interface en changeant les classes dans notre application Console. Notez que nous n’exécuterons pas le code car rien ne peut être exécuté à l’aide d’une interface.

Exemple d'interface C#

Créons une classe d'interface. Cette classe s'appellera «Guru99Interface. Notre classe principale étendra ensuite l'interface définie. Tout le code doit être écrit dans le fichier Program.cs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
 interface IGuru99Interface
 {
  void SetTutorial(int pID, string pName);
  String GetTutorial();
 }

 class Guru99Tutorial : IGuru99Interface
 {
  protected int TutorialID;
  protected string TutorialName;

  public void SetTutorial(int pID, string pName)
  {
   TutorialID = pID;
   TutorialName = pName;
  }

  public String GetTutorial()
  {
   return TutorialName;
  }

  static void Main(string[] args)
  {
   Guru99Tutorial pTutor = new Guru99Tutorial();

   pTutor.SetTutorial(1,".Net by Guru99");

   Console.WriteLine(pTutor.GetTutorial());

   Console.ReadKey();
  }
 }
}

Code Explication:-

Ici, nous expliquons les sections importantes du code

Exemple d'interface C#

  1. Nous définissons d'abord une interface appelée «Guru99Interface. Notez que le mot-clé « interface » est utilisé pour définir une interface.
  2. Ensuite, nous définissons les méthodes qui seront utilisées par notre interface. Dans ce cas, nous définissons les mêmes méthodes que celles utilisées dans tous les exemples précédents. Notez qu'une interface déclare simplement les méthodes. Il n'y définit pas le code.
  3. Nous faisons ensuite notre GuruLa classe 99Tutorial étend l'interface. C'est ici que nous écrivons le code qui définit les différentes méthodes déclarées dans l'interface. Ce type de code permet d'obtenir les résultats suivants :
    • Cela garantit que la classe, Guru99Tutorial ajoute uniquement le code nécessaire aux méthodes « SetTutorial » et « GetTutorial », et rien d'autre.
    • Cela garantit également que l'interface se comporte comme une interface utilisateur.trac La classe doit se conformer à la conventiontract. Donc si le contracSi la commande indique qu'elle devrait comporter deux méthodes appelées « SetTutorial » et « GetTutorial », alors elle devrait être conçue ainsi.

Interface C# vs Abstract Classe

Une question fréquente chez les débutants est de savoir en quoi une interface C# diffère d'une interface de type `interface`. Abdostracclasse TLes deux définissent une contracd'autres types suivent, mais ils servent des objectifs de conception différents.

Les principales différences sont énumérées ci-dessous :

  • Mise en œuvre: Une interface ne contient que des déclarations, tandis qu'une interface absoluetracLa classe T peut fournir à la fois des abstracmembres t et méthodes entièrement implémentées.
  • Héritage multiple : Une classe peut implémenter plusieurs interfaces mais ne peut hériter que d'une seule interface absolue.tracclasse t.
  • État: Un abdostracUne classe T peut contenir des champs, des constructeurs et des propriétés avec des données, tandis qu'une interface ne peut pas stocker d'état d'instance.
  • Modificateurs d'accès : AbdostracLes membres de la classe t peuvent être publics, protégés ou privés, tandis que les membres d'interface classiques sont implicitement publics.
  • Cas d'utilisation: Utilisez une interface pour ajouter une fonctionnalité à des types non liés, et une valeur absoluetracLa classe t permet de partager du code commun entre des types étroitement liés.

En bref, une interface décrit ce qu'une classe peut faire, tandis qu'une classe absoluetracLa classe t peut également définir une partie de la manière dont cela est fait.

Comment implémenter plusieurs interfaces en C#

Contrairement à l'héritage de classes, C# permet à une même classe d'implémenter plusieurs interfaces. C'est ainsi que le langage offre une forme sûre d'héritage multiple, sans l'ambiguïté qui résulte de l'héritage simultané de plusieurs classes de base.

Pour implémenter plusieurs interfaces, listez-les après le nom de la classe et séparez-les par une virgule. La classe doit ensuite définir chaque méthode déclarée dans chaque interface qu'elle implémente.

Étape 1) Déclarez deux interfaces, chacune avec sa propre méthode.

Étape 2) Créez une classe qui implémente les deux interfaces, en séparant les noms des interfaces par une virgule.

Étape 3) Fournissez un corps de méthode pour chaque membre déclaré dans chaque interface.

L'exemple ci-dessous montre une classe Document qui implémente à la fois une interface utilisateur et une interface graphique.Readable et une interface IWritable.

using System;
namespace DemoApplication
{
 interface IReadable
 {
  void Read();
 }
 interface IWritable
 {
  void Write();
 }
 class Document : IReadable, IWritable
 {
  public void Read()
  {
   Console.WriteLine("Reading the document");
  }
  public void Write()
  {
   Console.WriteLine("Writing to the document");
  }
  static void Main(string[] args)
  {
   Document doc = new Document();
   doc.Read();
   doc.Write();
   Console.ReadKey();
  }
 }
}

Code Explication:-

  1. Nous déclarons deux interfaces, IReadable et IWritable. Chaque interface déclare une seule méthode sans corps.
  2. La classe Document liste les deux interfaces après les deux-points, séparées par une virgule, acceptant ainsi de respecter les deux.tracts.
  3. La classe définit ensuite les méthodes Read et Write. Ignorerping L'une ou l'autre méthode provoquerait une erreur de compilation.
  4. La méthode Main crée un objet Document et appelle les deux méthodes, prouvant ainsi que la classe satisfait aux deux interfaces.

Lorsque le programme s'exécute, il imprime Lecture du document sur la première ligne et Rédiger le document sur la deuxième ligne. Ce motif conserve chaque contracElle est petite et ciblée, ce qui rend la classe Document plus facile à tester et à étendre.

Avantages de l'utilisation des interfaces en C#

Les interfaces sont largement utilisées dans les projets C# professionnels car elles rendent le code flexible et plus facile à maintenir. Elles permettent de programmer selon une approche conventionnelle.tract plutôt que dans une classe concrète.

Les principaux avantages comprennent:

  • Couplage lâche: Code Cela dépend de l'interface, et non d'une classe spécifique ; une implémentation peut donc changer sans perturber les appelants.
  • Héritage multiple : Une classe peut hériter du comportement de plusieurs interfaces, ce que l'héritage de classe classique ne permet pas.
  • Testabilité : Les interfaces simplifient le remplacement d'une classe réelle par un objet factice lors des tests unitaires.
  • Injection de dépendances : Les frameworks injectent une implémentation d'interface au moment de l'exécution, une idée centrale des principes SOLID.
  • Cohérence: Chaque classe d'implémentation est obligée de fournir le même ensemble de membres, ce qui garantit la prévisibilité de l'API.

Grâce à ces avantages, les interfaces sont au cœur de la plupart des modèles de conception et des frameworks d'applications C# modernes.

FAQ

Par convention, le nom d'une interface C# commence par la lettre I majuscule, comme IDisposable ou IReadableLe préfixe « I » indique immédiatement que le type est une interface plutôt qu'une classe ou une structure.

Avant C# 8.0, une interface ne contenait que des déclarations. À partir de C# 8.0, les méthodes d'interface par défaut permettent à une interface de fournir un corps de méthode, ce qui garantit la compatibilité des anciennes implémentations même avec l'ajout de nouveaux membres.

L'implémentation explicite nomme un membre avec son préfixe d'interface, tel que IReadable.Read. Le membre n'est alors appelable que par le biais d'une référence d'interface, ce qui évite les conflits de noms lorsque deux interfaces déclarent la même méthode.

Oui. Une interface peut hériter d'une ou plusieurs autres interfaces. Une classe qui implémente l'interface enfant doit alors définir toutes les méthodes de l'interface enfant et de toutes les interfaces parentes héritées.

Non. Une interface ne peut pas être instanciée directement car elle ne possède pas d'implémentation. Vous créez un objet d'une classe qui implémente l'interface, puis vous référencez cet objet via le type de l'interface.

Oui. Les membres d'une interface classique sont implicitement publics et il est impossible de leur ajouter des modificateurs d'accès. La classe implémentant l'interface doit également déclarer les membres correspondants comme publics.

Oui. GitHub Copilot peut générer la structure d'une interface, suggérer les signatures de ses méthodes et créer une classe qui l'implémente à partir d'un court commentaire ou du nom de l'interface, ce qui accélère le développement.tract-premier développement.

ML.NET s'appuie sur des interfaces telles que ITransformer et IDataView pour définir son pipeline d'apprentissage automatique. Le codage en fonction de ces interfacestracts vous permet de changer de modèles et de sources de données sans réécrire le code d'entraînement environnant.

Résumez cet article avec :