Cos'è l'interfaccia in C# con l'esempio

Cos'è l'interfaccia in C#?

An Interfaccia in C# viene utilizzato insieme a una classe per definire un contracL'interfaccia definisce cosa la classe fornirà a un'applicazione. L'interfaccia definisce quali operazioni una classe può eseguire. Un'interfaccia dichiara le proprietà e i metodi. Spetta alla classe definire esattamente cosa farà il metodo.

Diamo un'occhiata ad un esempio di interfaccia modificando le classi nella nostra applicazione Console. Tieni presente che non eseguiremo il codice perché non c'è nulla che possa essere eseguito utilizzando un'interfaccia.

Esempio di interfaccia C#

Creiamo una classe di interfaccia. La classe si chiamerà "Guru99Interface." La nostra classe principale estenderà quindi l'interfaccia definita. Tutto il codice deve essere scritto nel file 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 Spiegazione:-

Qui spieghiamo le sezioni importanti del codice

1. Definiamo innanzitutto un'interfaccia chiamata "Guru99Interfaccia." Si noti che la parola chiave "interfaccia" viene utilizzata per definire un'interfaccia.
2. Successivamente, stiamo definendo i metodi che saranno utilizzati dalla nostra interfaccia. In questo caso, stiamo definendo gli stessi metodi utilizzati in tutti gli esempi precedenti. Nota che un'interfaccia dichiara solo i metodi. Non definisce il codice in essi.
3. Poi facciamo il nostro Guru99La classe Tutorial estende l'interfaccia. Qui è dove scriviamo il codice che definisce i vari metodi dichiarati nell'interfaccia. Questo tipo di programmazione raggiunge i seguenti risultati:
   • Garantisce che la classe, Guru99Tutorial aggiunge solo il codice necessario per i metodi "SetTutorial" e "GetTutorial" e nient'altro.
   • Garantisce inoltre che l'interfaccia si comporti come un contracT. IL classe deve rispettare il contrattotract. Quindi se il contracSe dice che dovrebbe avere due metodi chiamati "SetTutorial" e "GetTutorial", allora è così che dovrebbe essere.

Interfaccia C# vs AbstracClasse t

Una domanda comune per i principianti è come un'interfaccia C# differisce da un' abstracclasse tEntrambi definiscono un contracche altri tipi seguono, tuttavia servono a scopi di progettazione diversi.

Le principali differenze sono elencate di seguito:

• Implementazione Un'interfaccia contiene solo dichiarazioni, mentre un'astrazionetracLa classe t può fornire entrambi gli addominalitracmembri t e metodi completamente implementati.
• Eredità multipla: Una classe può implementare molte interfacce ma può ereditare solo un'assolutatracclasse t.
• Stato: Un addominalitracUna classe t può contenere campi, costruttori e proprietà con dati, mentre un'interfaccia non può memorizzare lo stato dell'istanza.
• Modificatori di accesso: AbstracI membri della classe t possono essere pubblici, protetti o privati, mentre i membri dell'interfaccia classica sono implicitamente pubblici.
• Caso d'uso: Utilizzare un'interfaccia per aggiungere una capacità a tipi non correlati e un assolutotracLa classe t serve a condividere codice comune tra tipi strettamente correlati.

In breve, un'interfaccia descrive ciò che una classe può fare, mentre un'astrazionetracLa classe t può anche definire parte del modo in cui viene fatto.

Come implementare più interfacce in C#

A differenza dell'ereditarietà di classe, C# consente a una singola classe di implementare più di un'interfaccia. In questo modo il linguaggio offre una forma sicura di ereditarietà multipla, senza l'ambiguità che deriva dall'ereditarietà simultanea di diverse classi base.

Per implementare più interfacce, elencatele dopo il nome della classe e separatele con una virgola. La classe deve quindi definire ogni metodo dichiarato in ciascuna interfaccia che implementa.

Passo 1) Dichiarare due interfacce, ciascuna con il proprio metodo.

Passo 2) Crea una classe che implementi entrambe le interfacce, separando i nomi delle interfacce con una virgola.

Passo 3) Fornire un corpo di metodo per ogni membro dichiarato in ciascuna interfaccia.

L'esempio seguente mostra una classe Document che implementa entrambi un IReadable e un'interfaccia 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 Spiegazione:-

1. Dichiariamo due interfacce, IReadable e IWritable. Ciascuna interfaccia dichiara un singolo metodo senza corpo.
2. La classe Document elenca entrambe le interfacce dopo i due punti, separate da una virgola, quindi accetta di rispettare entrambe le interfaccetracts.
3. La classe definisce quindi i metodi Read e Write.ping Entrambi i metodi causerebbero un errore in fase di compilazione.
4. Il metodo Main crea un oggetto Document e chiama entrambi i metodi, dimostrando che la classe soddisfa le due interfacce.

Quando il programma viene eseguito, stampa Leggere il documento sulla prima riga e Scrivere al documento sulla seconda riga. Questo schema mantiene ogni contracÈ piccola e focalizzata, il che rende la classe Document più facile da testare ed estendere.

Vantaggi dell'utilizzo delle interfacce in C#

Le interfacce sono ampiamente utilizzate nei progetti C# professionali perché rendono il codice flessibile e più facile da mantenere. Permettono di programmare in modo coerentetracpiuttosto che a una classe concreta.

I principali vantaggi includono:

• Accoppiamento lasco: Code Dipende dall'interfaccia, non da una classe specifica, quindi l'implementazione può cambiare senza compromettere il funzionamento dei chiamanti.
• Eredità multipla: Una classe può ereditare il comportamento da diverse interfacce, cosa che la semplice ereditarietà tra classi non consente.
• Testabilità: Le interfacce semplificano la sostituzione di una classe reale con un oggetto fittizio durante i test unitari.
• Iniezione di dipendenza: I framework iniettano un'implementazione dell'interfaccia in fase di esecuzione, un'idea fondamentale alla base dei principi SOLID.
• Consistenza: Ogni classe che implementa tale funzionalità è obbligata a fornire lo stesso insieme di membri, il che garantisce la prevedibilità dell'API.

Grazie a questi vantaggi, le interfacce sono al centro della maggior parte dei moderni modelli di progettazione e framework applicativi C#.

DOMANDE FREQUENTI