Vad är gränssnitt i C# med exempel

Vad är Interface i C#?

An Gränssnitt i C# används tillsammans med en klass för att definiera en contract vilket är en överenskommelse om vad klassen ska tillhandahålla en applikation. Gränssnittet definierar vilka operationer en klass kan utföra. Ett gränssnitt deklarerar egenskaperna och metoderna. Det är upp till klassen att definiera exakt vad metoden ska göra.

Låt oss titta på ett exempel på ett gränssnitt genom att ändra klasserna i vår konsolapplikation. Observera att vi inte kommer att köra koden eftersom det inte finns något som kan köras med ett gränssnitt.

Exempel på C#-gränssnitt

Låt oss skapa en gränssnittsklass. Klassen kommer att kallas "Guru99Interface.” Vår huvudklass kommer sedan att utöka det definierade gränssnittet. All kod måste skrivas 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 Förklaring:-

Här förklarar vi de viktiga delarna av koden

1. Vi definierar först ett gränssnitt som heter "Guru99Interface.” Observera att nyckelordet ”gränssnitt” används för att definiera ett gränssnitt.
2. Därefter definierar vi metoderna som kommer att användas av vårt gränssnitt. I det här fallet definierar vi samma metoder som används i alla tidigare exempel. Observera att ett gränssnitt bara deklarerar metoderna. Den definierar inte koden i dem.
3. Sedan gör vi våra Guru99Handledningsklassen utökar gränssnittet. Här skriver vi koden som definierar de olika metoderna som deklareras i gränssnittet. Denna typ av kodning uppnår följande
   • Det säkerställer att klassen, Guru99Tutorial lägger bara till den kod som är nödvändig för metoderna ”SetTutorial” och ”GetTutorial” och inget annat.
   • Det säkerställer också att gränssnittet beter sig som en blufftract. Den klass måste följa reglernatract. Så om nackdelentracOm det säger att den ska ha två metoder som heter "SetTutorial" och "GetTutorial", då är det så det ska vara.

C#-gränssnitt kontra ABStract-klass

En vanlig fråga för nybörjare är hur ett C#-gränssnitt skiljer sig från ett abstracT-klassBåda definierar en nackdeltracatt andra typer följer, men de tjänar andra designmål.

De viktigaste skillnaderna listas nedan:

• Genomförande: Ett gränssnitt innehåller endast deklarationer, medan ett abstract-klassen kan ge både magmusklertract-medlemmar och fullt implementerade metoder.
• Multipelt arv: En klass kan implementera många gränssnitt men kan bara ärva ett abstract-klass.
• Ange: En magmuskeltract-klassen kan innehålla fält, konstruktörer och egenskaper med data, medan ett gränssnitt inte kan lagra instanstillstånd.
• Åtkomstmodifierare: AbstracMedlemmar i t-klassen kan vara offentliga, skyddade eller privata, medan medlemmar i klassiska gränssnitt implicit är offentliga.
• Användningsfall: Använd ett gränssnitt för att lägga till en funktion över orelaterade typer och en abstract-klassen för att dela gemensam kod mellan närbesläktade typer.

Kort sagt beskriver ett gränssnitt vad en klass kan göra, medan en abstract-klassen kan också definiera en del av hur det görs.

Hur man implementerar flera gränssnitt i C#

Till skillnad från klassarv tillåter C# en enda klass att implementera mer än ett gränssnitt. Det är så språket erbjuder en säker form av multipel arv utan den tvetydighet som uppstår när man ärver flera basklasser samtidigt.

För att implementera flera gränssnitt, lista dem efter klassnamnet och separera varje gränssnitt med ett kommatecken. Klassen måste sedan definiera varje metod som deklareras i varje gränssnitt den implementerar.

Steg 1) Deklarera två gränssnitt, vart och ett med sin egen metod.

Steg 2) Skapa en klass som implementerar båda gränssnitten och separera gränssnittsnamnen med ett kommatecken.

Steg 3) Ange en metodkropp för varje medlem som deklareras i varje gränssnitt.

Exemplet nedan visar en Document-klass som implementerar både ett IReadable och ett IWritable-gränssnitt.

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 Förklaring:-

1. Vi deklarerar två gränssnitt, jagReadable och IWritable. Varje gränssnitt deklarerar en enda metod utan en brödtext.
2. Klassen Document listar båda gränssnitten efter kolon, separerade med ett kommatecken, så den accepterar att respektera båda kontracts.
3. Klassen definierar sedan metoderna Läs och Skriv.ping båda metoderna skulle orsaka ett kompileringsfel.
4. Main-metoden skapar ett Document-objekt och anropar båda metoderna, vilket bevisar att klassen uppfyller de två gränssnitten.

När programmet körs skriver det ut Läser dokumentet på första raden och Skriver till dokumentet på den andra raden. Detta mönster håller varje kontract liten och fokuserad, vilket gör Document-klassen enklare att testa och utöka.

Fördelar med att använda gränssnitt i C#

Gränssnitt används ofta i professionella C#-projekt eftersom de gör kod flexibel och lättare att underhålla. De låter dig programmera till en standardiserad nivå.tract snarare än till en konkret klass.

De viktigaste fördelarna inkluderar:

• Lös koppling: Code beror på gränssnittet, inte en specifik klass, så en implementering kan ändras utan att anroparna bryts.
• Multipelt arv: En klass kan ärva beteende från flera gränssnitt, vilket vanligt klassarv inte tillåter.
• Testbarhet: Gränssnitt gör det enkelt att byta ut en riktig klass mot ett mock-objekt under enhetstestning.
• Beroendeinjektion: Ramverk injicerar en gränssnittsimplementering vid körning, en kärnidé bakom SOLID-principerna.
• Konsistens: Varje implementerande klass tvingas tillhandahålla samma uppsättning medlemmar, vilket gör att ett API håller sig förutsägbart.

På grund av dessa fördelar ligger gränssnitt i hjärtat av de flesta moderna C#-designmönster och applikationsramverk.

Vanliga frågor