Wat is Interface in C# met voorbeeld

Wat is interface in C#?

An Interface In C# wordt het samen met een klasse gebruikt om een ​​context te definiëren.tracEen interface is een overeenkomst over wat de klasse aan een applicatie zal leveren. De interface definieert welke bewerkingen een klasse kan uitvoeren. Een interface declareert de eigenschappen en methoden. Het is aan de klasse om precies te definiëren wat de methode zal doen.

Laten we een voorbeeld bekijken van een interface door de klassen in onze Console-applicatie te wijzigen. Houd er rekening mee dat we de code niet zullen uitvoeren, omdat er niets is dat via een interface kan worden uitgevoerd.

C#-interfacevoorbeeld

Laten we een interfaceklasse maken. De klasse zal de naam "Guru99Interface.” Onze hoofdklasse zal vervolgens de gedefinieerde interface uitbreiden. Alle code moet in het bestand Program.cs worden geschreven.

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 Uitleg:-

Hier leggen we de belangrijke delen van de code uit

1. We definiëren eerst een interface genaamd "Guru99Interface.” Merk op dat het sleutelwoord “interface” wordt gebruikt om een ​​interface te definiëren.
2. Vervolgens definiëren we de methoden die door onze interface worden gebruikt. In dit geval definiëren we dezelfde methoden die in alle eerdere voorbeelden worden gebruikt. Let op: een interface declareert alleen de methoden. Het definieert niet de code erin.
3. Vervolgens maken we onze GuruDe 99Tutorial-klasse breidt de interface uit. Hier schrijven we de code die de verschillende methoden definieert die in de interface zijn gedeclareerd. Dit soort code bereikt het volgende:
   • Het zorgt ervoor dat de klas, Guru99Tutorial voegt alleen de code toe die nodig is voor de methoden "SetTutorial" en "GetTutorial" en verder niets.
   • Het zorgt er ook voor dat de interface zich gedraagt ​​als een contract. De klasse moet zich aan de overeenkomst houdentract. Dus als de contracAls er staat dat er twee methoden moeten zijn, genaamd "SetTutorial" en "GetTutorial", dan is dat precies zoals het hoort.

C# Interface versus Abstract Klasse

Een veelgestelde vraag van beginners is hoe een C#-interface verschilt van een abstract-klasseBeide definiëren een contracdat andere typen volgen, maar dat ze verschillende ontwerpdoelen dienen.

De belangrijkste verschillen staan ​​hieronder vermeld:

• Implementatie: Een interface bevat alleen declaraties, terwijl een interface abstracDe T-klasse kan zowel buikspieren als andere buikspieren bieden.tract leden en volledig geïmplementeerde methoden.
• Meerdere overerving: Een klasse kan veel interfaces implementeren, maar kan er slechts één overerven.tract-klasse.
• Staat: Een buiktracEen klasse kan velden, constructors en eigenschappen met data bevatten, terwijl een interface geen instantie-status kan opslaan.
• Toegangsmodifiers: AbstracLeden van een t-klasse kunnen openbaar, beveiligd of privé zijn, terwijl leden van een klassieke interface impliciet openbaar zijn.
• Use case: Gebruik een interface om een ​​functionaliteit toe te voegen aan verschillende typen, en een abstract-klasse om gemeenschappelijke code te delen tussen nauw verwante typen.

Kort gezegd beschrijft een interface wat een klasse kan doen, terwijl een abstractielaag (abs) dat niet kan.tracDe klasse t kan ook een deel van de werkwijze definiëren.

Hoe implementeer je meerdere interfaces in C#?

In tegenstelling tot klasse-overerving, staat C# toe dat één klasse meer dan één interface implementeert. Op deze manier biedt de taal een veilige vorm van meervoudige overerving zonder de ambiguïteit die ontstaat bij het tegelijkertijd overerven van meerdere basisklassen.

Om meerdere interfaces te implementeren, vermeldt u deze na de klassenaam en scheidt u ze met een komma. De klasse moet vervolgens elke methode definiëren die is gedeclareerd in elke interface die zij implementeert.

Stap 1) Declareer twee interfaces, elk met een eigen methode.

Stap 2) Maak een klasse die beide interfaces implementeert, waarbij je de interfacenamen scheidt met een komma.

Stap 3) Geef voor elk lid dat in elke interface is gedeclareerd een methodebody op.

Het onderstaande voorbeeld toont een Document-klasse die zowel een I implementeertReadable en een IWritable-interface.

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 Uitleg:-

1. We declareren twee interfaces, IReadable en IWritable. Elke interface declareert een enkele methode zonder body.
2. De klasse Document vermeldt beide interfaces na de dubbele punt, gescheiden door een komma, en stemt er dus mee in om beide interfaces te respecteren.tracts.
3. De klasse definieert vervolgens de methoden Read en Write. Overslaanping Beide methoden zouden een compileerfout veroorzaken.
4. De Main-methode maakt een Document-object aan en roept beide methoden aan, waarmee bewezen wordt dat de klasse aan beide interfaces voldoet.

Wanneer het programma wordt uitgevoerd, print het het volgende af. Het document lezen op de eerste regel en Schrijven naar het document op de tweede regel. Dit patroon zorgt ervoor dat elke contracHet is klein en gefocust, waardoor de Document-klasse gemakkelijker te testen en uit te breiden is.

Voordelen van het gebruik van interfaces in C#

Interfaces worden veel gebruikt in professionele C#-projecten omdat ze de code flexibeler en gemakkelijker te onderhouden maken. Ze stellen je in staat om te programmeren met een interface die...tract in plaats van naar een concrete klasse.

De belangrijkste voordelen zijn:

• Losse koppeling: Code Het hangt af van de interface, niet van een specifieke klasse, dus een implementatie kan veranderen zonder dat dit problemen veroorzaakt voor de aanroepende programma's.
• Meerdere overerving: Een klasse kan gedrag overerven van meerdere interfaces, iets wat bij gewone klasse-overerving niet mogelijk is.
• Testbaarheid: Interfaces maken het eenvoudig om tijdens unit-testen een echte klasse te vervangen door een mock-object.
• Afhankelijkheidsinjectie: Frameworks injecteren een interface-implementatie tijdens de uitvoering, een kernidee achter de SOLID-principes.
• Consistentie: Elke implementerende klasse is gedwongen dezelfde set leden te leveren, wat de API voorspelbaar houdt.

Vanwege deze voordelen vormen interfaces de kern van de meeste moderne C#-ontwerppatronen en applicatie-frameworks.

Veelgestelde vragen