C# virtuale

Una funzione virtuale in C# può essere annullata nelle sottoclassi. Una funzione virtuale in C# ha un'implementazione di classe genitore e figlio. Ogni volta che la funzionalità di base di un metodo è quasi la stessa, tuttavia, la sottoclasse richiede ulteriori capacità e viene utilizzata. La frase virtuale viene utilizzata per definire una funzione virtuale nella superclasse, che viene quindi sovrascritta dalla frase di sovraccarico nella sottoclasse. Ogni volta che una funzione viene specificata come una funzione virtuale in una superclasse, la sottoclasse può scegliere se sovrascriverla o meno. La metodologia prevalente consente a una funzione di avere molte forme. Di conseguenza, è una buona illustrazione del polimorfismo. Iniziamo con l'utilizzo di alcuni degli esempi C# per elaborare il funzionamento della parola chiave "virtuale" per creare e utilizzare le funzioni virtuali nel codice. Dobbiamo creare un file C# in cui possiamo aggiungere il codice per le funzioni virtuali con la query "Touch" come di seguito.

Esempio # 01

Iniziamo con l'esempio più elementare dell'utilizzo del metodo virtuale in C#. Utilizzeremo la libreria di sistema all'interno del nostro codice nella prima riga utilizzando la parola chiave "usando" come visualizzato. Dopo questo, abbiamo creato una classe di base pubblica denominata "genitore" usando la parola chiave "classe". Questa classe di base contiene un'unica funzione denominata "Show" di tipo di ritorno void e modificatore di accesso pubblico, i.e., funzione virtuale.

Questa funzione virtuale contiene una semplice dichiarazione di funzione WriteLine () della classe Console per stampare la semplice frase di testo sull'esecuzione nel nostro schermo, i.e., "Metodo virtuale nella classe genitore". Un'altra classe pubblica chiamata "Child" è stata creata dopo. Come mostrato, questa classe è stata derivata dalla classe "genitore". Il metodo "show" è stato implementato al suo interno che è stato sovrascritto dalla classe di base "genitore" utilizzando la parola chiave "override" seguita dal tipo di ritorno "void" e avviato con il modificatore di accesso "pubblico".

Poiché questa funzione virtuale è stata ignorata dalla classe base, deve contenere un'implementazione extra. Pertanto, abbiamo usato qui l'istruzione WriteLine () della classe Console per visualizzare una nuova stringa di testo nella shell indicando "Metodo virtuale prevalente nella classe figlio". Entrambe le funzioni della classe genitore e figlio sono dello stesso nome ma un po 'di implementazione. Tutta questa implementazione funzionerà dopo aver utilizzato il metodo principale () nel codice. Quindi, abbiamo creato una nuova classe indipendente denominata "New" con la parola chiave "classe". Questa classe contiene un metodo principale di tipo statico () con un tipo di ritorno vuoto. L'esecuzione è iniziata dalla creazione di un oggetto Classe Parente "O1" con la parola chiave "Nuovo" seguito dal nome della classe. Abbiamo usato questo nuovo oggetto O1 per chiamare la funzione virtuale "mostra" dalla classe principale. Successivamente, abbiamo creato un altro oggetto O2 per la classe figlio usando la parola chiave "nuovo", iniziando con il nome della classe base e finendo con il nome della classe figlio. Ciò dimostra che l'effettiva eredità ha avuto luogo nel codice C#. L'oggetto di classe figlio "O2" è stato utilizzato per chiamare la funzione virtuale "Show" sovrascritta della classe figlio. La chiamata di funzione non deve essere confusa durante l'esecuzione del metodo principale (). Inoltre, dovremmo ottenere la funzione show () della classe genitore eseguita prima e poi la funzione show () della funzione della classe figlio. La nuova classe è terminata qui e il nostro codice è ora completato.

Dopo aver salvato questo codice all'interno dell'editor di testo, siamo tornati al terminale poiché il nostro codice deve essere compilato con il compilatore "MCS" C#. Dopo la compilazione riuscita, abbiamo provato l'esecuzione del suo file "exe" appena creato nella cartella domestica con il runtime "mono" di C#. Ha eseguito il codice e visualizzato prima la stringa del metodo virtuale dalla classe genitore e quindi il testo della stringa del metodo Show () di Overridden Show () della classe figlio.

Esempio # 02

Rendiamo il nostro codice un po 'avanzato e diverso dall'esempio sopra. Lo abbiamo avviato con l'utilizzo della libreria di sistema nella prima riga di codice. Successivamente, abbiamo utilizzato un test dei nomi delle classi globali contenente altre tre classi e una funzione principale (). La prima classe, "rettangolo", è una classe genitore delle altre due classi. Abbiamo dichiarato 3 variabili pubbliche a doppio tipo "H", "W" e "R" in esso con 10, 4 e 3, rispettivamente. Una variabile costante a doppio tipo "P" è stata dichiarata con un valore "Pi" incorporato della matematica. Qui è stato definito un metodo virtuale "area ()" di doppio rendimento che ha restituito il risultato di moltiplicazione di "H" e "W" alla funzione principale () della classe di test, i.e., L'area di un rettangolo è, l'altezza si moltiplica per larghezza. La classe "Square" è stata derivata dalla classe "rettangolo". Questa classe sta preparando la funzione virtuale "Area" dalla sua classe base e restituendo il risultato di moltiplicazione di "H" e "H", i.e., L'area di un quadrato è un lato moltiplicato per il secondo lato o altezza in altezza.

Quindi, abbiamo una classe derivata "Circle" che prevede la funzione virtuale "area" dal rettangolo di classe di base. Questa funzione restituisce il risultato di moltiplicazione di "p" e "r*r", i.e., L'area di un cerchio è "pi" moltiplicata per il quadrato di un raggio. Tre classi sono state definite e implementate nel codice completamente. Ora, è il turno della funzione principale () di C# per iniziare la sua esecuzione ed eseguire gradualmente le classi. All'interno del metodo principale () della classe di test, abbiamo creato un oggetto "O1" del rettangolo della classe genitore in prima riga usando il nome di una classe con la "nuova" parola chiave.

Usando la classe rettangolare, abbiamo creato oggetti O2 e O3 per le classi derivate quadrate e cerchio, rispettivamente. Tre dichiarazioni WriteLine () della classe Console sono state utilizzate qui per visualizzare l'area di rettangolo, quadrato e cerchio, rispettivamente. Per calcolare l'area per tre forme, abbiamo usato i rispettivi oggetti di ciascuna classe di forma. Questi oggetti hanno chiamato le rispettive funzioni virtuali definite nella classe rettangolare e sovrascritte all'interno delle classi derivate, i.e., Quadrato e cerchio.

È tempo di compilare questo codice C# appena creato nella shell con l'istruzione del comando "MCS". Successivamente, utilizzare l'istruzione di runtime mono per eseguire il file "exe" che è stato generato a seguito della compilation. Durante l'esecuzione di questo file "exe" per il codice, abbiamo ottenuto l'area di rettangolo, quadrato e cerchio visualizzato sul nostro schermo poiché abbiamo usato la funzione virtuale in una classe e la abbiamo annullato nelle classi derivate.

Conclusione

Abbiamo descritto come una semplice funzione virtuale C# può essere utilizzata all'interno del codice C# e sovrascritta nelle sue sottoclassi. Abbiamo dimostrato il suo lavoro all'interno di questo articolo con l'aiuto di alcuni esempi. Il primo esempio ha illustrato l'utilizzo della funzione virtuale all'interno del singolo programma di eredità, mentre il secondo esempio dimostra che con l'aiuto di eredità multiple. Ecco come abbiamo mostrato come un metodo semplice può essere utilizzato per eseguire più calcoli con la singola definizione di una funzione in C#.