Hva er grensesnitt i C# med eksempel

Hva er grensesnitt i C#?

An Interface i C# brukes sammen med en klasse for å definere en kontract som er en avtale om hva klassen skal gi til et program. Grensesnittet definerer hvilke operasjoner en klasse kan utføre. Et grensesnitt deklarerer egenskapene og metodene. Det er opp til klassen å definere nøyaktig hva metoden skal gjøre.

La oss se på et eksempel på et grensesnitt ved å endre klassene i vår konsollapplikasjon. Merk at vi ikke kjører koden fordi det ikke er noe som kan kjøres ved hjelp av et grensesnitt.

Eksempel på C#-grensesnitt

La oss lage en grensesnittklasse. Klassen vil bli kalt «Guru99Interface.» Hovedklassen vår vil deretter utvide det definerte grensesnittet. All koden må skrives i Program.cs-filen.

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

Her forklarer vi de viktige delene av koden

1. Vi definerer først et grensesnitt kalt «Guru99Interface.» Merk at nøkkelordet «grensesnitt» brukes til å definere et grensesnitt.
2. Deretter definerer vi metodene som skal brukes av grensesnittet vårt. I dette tilfellet definerer vi de samme metodene som er brukt i alle tidligere eksempler. Merk at et grensesnitt bare erklærer metodene. Den definerer ikke koden i dem.
3. Så lager vi våre Guru99Tutorial-klassen utvider grensesnittet. Her skriver vi koden som definerer de ulike metodene som er deklarert i grensesnittet. Denne typen koding oppnår følgende
   • Det sikrer at klassen, Guru99Tutorial legger bare til koden som er nødvendig for metodene «SetTutorial» og «GetTutorial» og ingenting annet.
   • Det sikrer også at grensesnittet oppfører seg som en svindel.tract. Den klasse må overholde konvensjonentract. Så hvis ulempentracHvis det står at den skal ha to metoder kalt «SetTutorial» og «GetTutorial», så er det slik det skal være.

C#-grensesnitt vs. Abstract-klasse

Et vanlig spørsmål for nybegynnere er hvordan et C#-grensesnitt skiller seg fra et abstracT-klasseBegge definerer en ulempetracat andre typer følger, men de tjener andre designmål.

De viktigste forskjellene er listet opp nedenfor:

• Gjennomføring: Et grensesnitt inneholder bare deklarasjoner, mens et abstract-klassen kan gi både magemusklertract-medlemmer og fullt implementerte metoder.
• Multippel arv: En klasse kan implementere mange grensesnitt, men kan bare arve én ABStract-klassen.
• Tilstand: En magemuskeltract-klassen kan inneholde felt, konstruktører og egenskaper med data, mens et grensesnitt ikke kan lagre instanstilstand.
• Tilgangsmodifikatorer: AbstracMedlemmer i t-klassen kan være offentlige, beskyttede eller private, mens medlemmer i klassiske grensesnitt implisitt er offentlige.
• Bruk tilfelle: Bruk et grensesnitt for å legge til en funksjon på tvers av urelaterte typer, og en abstract-klassen for å dele felles kode mellom nært beslektede typer.

Kort sagt beskriver et grensesnitt hva en klasse kan gjøre, mens en abstract-klassen kan også definere deler av hvordan det gjøres.

Slik implementerer du flere grensesnitt i C#

I motsetning til klassearv, tillater C# en enkelt klasse å implementere mer enn ett grensesnitt. Slik tilbyr språket en sikker form for multippel arv uten tvetydigheten som oppstår ved å arve flere basisklasser samtidig.

For å implementere flere grensesnitt, oppgi dem etter klassenavnet og atskil hvert grensesnitt med komma. Klassen må deretter definere hver metode som er deklarert i hvert grensesnitt den implementerer.

Trinn 1) Deklarer to grensesnitt, hvert med sin egen metode.

Trinn 2) Lag en klasse som implementerer begge grensesnittene, og separer grensesnittnavnene med komma.

Trinn 3) Oppgi en metodekropp for hvert medlem som er deklarert i hvert grensesnitt.

Eksemplet nedenfor viser en Document-klasse som implementerer både en IReadable og et IWritable-grensesnitt.

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

1. Vi deklarerer to grensesnitt, jegReadable og IWritable. Hvert grensesnitt deklarerer én metode uten brødtekst.
2. Dokument-klassen viser begge grensesnittene etter kolon, atskilt med komma, slik at den godtar begge konfigurasjonene.tracts.
3. Klassen definerer deretter metodene Read og Write. Hopp overping Begge metodene ville forårsake en kompileringsfeil.
4. Main-metoden oppretter et Document-objekt og kaller begge metodene, noe som beviser at klassen tilfredsstiller de to grensesnittene.

Når programmet kjører, skriver det ut Leser dokumentet på den første linjen og Skriver til dokumentet på den andre linjen. Dette mønsteret holder hver kontract liten og fokusert, noe som gjør det enklere å teste og utvide Dokument-klassen.

Fordeler med å bruke grensesnitt i C#

Grensesnitt brukes mye i profesjonelle C#-prosjekter fordi de gjør kode fleksibel og enklere å vedlikeholde. De lar deg programmere til en standardiserttract snarere enn til en konkret klasse.

De viktigste fordelene inkluderer:

• Løs kobling: Code avhenger av grensesnittet, ikke en spesifikk klasse, så en implementering kan endres uten å ødelegge kallerne.
• Multippel arv: En klasse kan arve atferd fra flere grensesnitt, noe vanlig klassearv ikke tillater.
• Testbarhet: Grensesnitt gjør det enkelt å bytte ut en ekte klasse med et mock-objekt under enhetstesting.
• Avhengighetsinjeksjon: Rammeverk injiserer en grensesnittimplementering under kjøretid, en kjerneidé bak SOLID-prinsippene.
• Konsistens: Hver implementeringsklasse er tvunget til å tilby det samme settet med medlemmer, noe som holder et API forutsigbart.

På grunn av disse fordelene ligger grensesnitt i hjertet av de fleste moderne C#-designmønstre og applikasjonsrammeverk.

Spørsmål og svar