C# eredità multipla

I programmatori possono utilizzare molteplici eredità per costruire classi che integrano funzionalità di varie classi e gerarchie. È anche utile quando una classe figlio vuole combinare i contratti di classe di base. L'eredità multipla non è supportata in C# perché i programmatori ritengono che aggiunga una complessità eccessiva al lingua. Nel linguaggio di programmazione C#, le classi possono ereditare solo da una classe genitore, che viene definita singola eredità.

Tuttavia, possono essere utilizzate interfacce o una combinazione di classe e interfacce, con le interfacce seguite dal nome della classe nella firma. Questo articolo mostra come ottenere un'eredità multipla in C# utilizzando approcci diversi.

Quali sono le interfacce C#

L'eredità multipla non è fattibile con le classi, come sappiamo, ma è realizzabile con le interfacce quando viene utilizzata la parola chiave dell'interfaccia. L'interfaccia fornisce solo le definizioni di metodi, proprietà, eventi e indici, ma non fornisce alcuna implementazione del codice. Non possiamo aggiungere modificatori di accesso ai membri dell'interfaccia poiché sono implicitamente pubblici e astratti. Variabili, membri costanti, costruttori, distruttori e membri statici non sono tutti ammessi in un'interfaccia.

Importanza delle interfacce C#

Un'interfaccia non è la stessa di una classe. Ha solo firme del metodo. Non può essere creato poiché non ha alcuna implementazione. Le classi derivate da esso offrono la logica di implementazione. Un'interfaccia è spesso considerata una classe astratta pura. Tuttavia, l'utilizzo di un'interfaccia piuttosto che una classe astratta ha il vantaggio di supportare l'eredità multipla.

Come implementare le interfacce per C# Ereditarietà multipla

Nel linguaggio C#, ci sono numerosi approcci per raggiungere molteplici funzionalità di eredità. Per conoscere le basi dell'utilizzo delle interfacce per implementare più eredità, abbiamo alcuni programmi nelle seguenti illustrazioni:

Esempio n. 1: implementazione dell'eredità di più classe

Stiamo cercando di implementare l'eredità multipla nella classe seguente. Inizialmente, cerchiamo di ereditare le proprietà della prima classe genitore e della seconda classe genitore nella classe figlio. Tuttavia, il compilatore lancerà l'errore di runtime poiché C# non supporta direttamente l'eredità di classe.

Abbiamo incluso le librerie di sistemi all'inizio del codice. Dopodiché, abbiamo creato una classe genitore, "frutti" e abbiamo anche definito un metodo della classe come "myfruits". Nel metodo "MyFruits", abbiamo creato un elenco come "MyList" e aggiunto diversi elementi all'elenco utilizzando il metodo ADD. Il ciclo foreach viene utilizzato per iterare su ciascun elemento nell'elenco e assegnare gli elementi dell'elenco a una nuova variabile, "elementi". Quindi, abbiamo creato un'altra classe genitore, "FruitColors" e fornito il metodo "Colori" per l'implementazione. Abbiamo anche aggiunto gli elementi nell'elenco della classe "colori" come nella classe precedente.

Ora abbiamo una classe per bambini chiamata "FruitDetails", e questa classe figlio eredita le due classi di genitori date. Alla fine, abbiamo la classe principale "GetDetails", in cui abbiamo un metodo principale, e abbiamo creato l'oggetto della classe figlio "FruitsDetails" nel metodo principale. Questi oggetti invocano il metodo della classe principale qui, che causerà ambiguità nel codice.

Al momento della compilation, il programma di cui sopra genera un'eccezione che "le classi non possono avere più classi di base", come mostrato nella seguente immagine:

Esempio n. 2: Implementazione dell'interfaccia per l'eredità multipla

Anche se C# non implementa più eredità con le classi, possiamo raggiungerlo usando l'interfaccia. Sebbene le interfacce forniscano completa astrazione, non sono in grado di includere metodi specifici.

Nel codice precedente, abbiamo creato l'interfaccia con la parola chiave "interfaccia" e l'interfaccia viene fornita il nome "interface1". Abbiamo creato solo un metodo "nomi" e nient'altro nell'interfaccia. Quindi, abbiamo definito una classe genitore, "studente", per la quale abbiamo creato un'interfaccia. Nella classe principale, abbiamo fornito l'implementazione per il metodo "nomi". Nel metodo "nomi", abbiamo un elenco di array rappresentati come "elenco" in cui abbiamo aggiunto nomi casuali utilizzando il metodo ADD. The WriteLine stampa gli elementi dell'elenco. Il ciclo foreach viene utilizzato qui per iterare su ciascun elemento dell'elenco con l'aiuto dei "valori" variabili appena creati.

Quindi, abbiamo creato un'altra interfaccia, "interface2", per la seconda classe genitore. L'interfaccia ha solo il metodo "soggetti". Abbiamo la nostra seconda classe genitore, che implementa il metodo di interfaccia "soggetti". Quindi, abbiamo aggiunto gli elementi nell'elenco come nella prima classe genitore. Successivamente, abbiamo la classe figlio "Dettagli", che eredita le due interfacce specificate, "Interface1" e "Interface2". Nella classe Child, abbiamo creato gli oggetti per le classi genitori e accedevano direttamente ai metodi "Nomi" e "Soggetti" usando questi oggetti. I metodi "nomi" e "soggetti" non sono modificati poiché le interfacce sono ereditate dalla classe figlio. Alla fine del codice, abbiamo una classe principale, "demo", per dichiarare gli oggetti della classe figlio e mostrare i risultati.

Di seguito sono riportati i risultati che abbiamo ottenuto dall'implementazione dell'eredità di più classi usando le interfacce:

Esempio n. 3: l'implementazione dell'interfaccia eredita un'altra interfaccia

L'eredità da un'interfaccia a un'altra interfaccia è possibile in C#. Quando una classe definisce un'interfaccia ereditata, deve implementare tutti i membri dichiarati all'interno della catena di eredità. Si noti che se una classe utilizza un'interfaccia, tutti i metodi forniti da tale interfaccia devono essere implementati insieme ai metodi di interfaccia di base. Altrimenti, un errore viene lanciato dal compilatore. Quando vengono specificate sia un'interfaccia derivata che un'interfaccia di base, il nome del membro dell'interfaccia derivata nasconde il nome del membro dell'interfaccia di base.

Nel codice precedente, abbiamo dichiarato un'interfaccia "libri" e creato un metodo "book_no" nell'interfaccia. Si noti che non abbiamo definito un metodo con alcun specificatore di accesso. Per impostazione predefinita, i metodi di interfaccia sono pubblici. Se assegniamo qualsiasi specificatore di accesso ad esso, il compilatore lancia un errore. Quindi, abbiamo implementato un'altra interfaccia, "Dettagli", che eredita l'interfaccia "libri". Abbiamo anche un metodo per questa interfaccia. La classe è creata con il nome "Autore", per il quale abbiamo implementato le interfacce precedenti. La classe eredita solo l'interfaccia "dettagli", ma abbiamo ereditato i metodi di entrambe le interfacce qui. Alla fine, abbiamo definito una classe di driver "demo", in cui abbiamo creato un oggetto per l'autore di classe e abbiamo chiamato questi oggetti per accedere ai metodi di classe "autore". Quindi, abbiamo passato i valori a questi metodi.

Quello che segue è l'output che otteniamo dall'eredità dell'interfaccia a un'altra interfaccia:

Conclusione

Abbiamo discusso del concetto di eredità multipla in C#. E siamo venuti a sapere che in C è consentita una sola eredità, sebbene l'eredità multipla possa essere realizzata utilizzando contemporaneamente una o più interfacce. Abbiamo una chiara definizione dell'interfaccia insieme alla sua importanza. Abbiamo anche implementato l'interfaccia nel codice di esempio per dimostrare come l'interfaccia può essere utilizzata in C#. Inoltre, l'utilizzo delle interfacce è molto utile in quanto nascondono l'implementazione di una classe dal mondo esterno. Ora, spero che tu abbia imparato a conoscere l'eredità multipla in C#. Altri argomenti correlati su C# sono disponibili su Linux Suggerimento.