Come utilizzare il metodo virtuale in C#
Cos'è il metodo virtuale in C#
I metodi virtuali in C# sono metodi dichiarati in una classe di base e possono essere sovrascritti da classi derivate. In altre parole, un metodo virtuale è un metodo che può essere ridefinito in una sottoclasse, ecco la sintassi per esso:
Veride virtuale pubblico// Implementazione del metodo
La parola chiave virtuale indica che questo metodo può essere sovrascritto da una classe derivata e quando una classe derivata sovrascrive un metodo virtuale, fornisce la propria implementazione del metodo.
Per sovrascrivere un metodo virtuale in una classe derivata, si include la parola chiave di override nella firma del metodo e sotto è la sintassi per esso:
Vuoto di sostituzione del pubblico// Implementazione del metodo
La parola chiave di override indica che questo metodo sta preparando un metodo virtuale nella classe principale. Ecco uno snippet di codice di esempio che dimostra l'uso di metodi virtuali in C#:
usando il sistema;// Definisci una classe di base denominata calcolo
Calcolo della classe
// Definisci un metodo ADD virtuale che prende due numeri interi e restituisce un risultato intero
Public Virtual Int Add (int x, int y)
restituire x + y; // restituisce la somma dei due numeri interi di input
// Definisci una classe derivata denominata Customcalculation che eredita dal calcolo
Classe Customcalculation: calcolo
// sovrascrivi il metodo ADD della classe base
PUBBLICO OVERRIDE INT ADD (int x, int y)
if (x> 10 || y> 10) // se uno degli interi di input è maggiore di 10
restituire x - y; // sottrai y da x e restituisce il risultato
altro // se nessuno dei numeri interi di input è maggiore di 10
base di ritorno.Aggiungi (x, y); // Chiama il metodo ADD della classe base per restituire la somma dei due numeri interi di input
Programma di classe
statico void main (string [] args)
// crea un'istanza della classe base denominata calcolo
Calcolo calc = new Calculation ();
// Crea un'istanza della classe derivata denominata Customcalculation
CustomCalCulationCustomCalc = new CustomCalCulation ();
// Chiama il metodo Aggiungi virtuale sull'oggetto di calcolo di base
int risultato1 = calc.Aggiungi (5, 7);
Console.WriteLine ($ "Result1: risultato1"); // output: risultato1: 12
// Chiama il metodo Aggiungi sovrascritto sull'oggetto personalizzato
int risultato2 = Customcalc.Aggiungi (12, 7);
Console.WriteLine ($ "Result2: risultato2"); // output: risultato2: 5
In questo esempio, abbiamo una classe di base chiamata Calcolo con un metodo virtuale chiamato ADD che aggiunge semplicemente due numeri interi insieme. Abbiamo anche una classe derivata chiamata Customcalculation che sovrascrive il metodo ADD, ma solo quando la somma dei due numeri è maggiore di 10.
Nel metodo Aggiungi sovrascritto, controlliamo se x o y è maggiore di 10. Se questa condizione è vera, restituiamo la differenza tra xey e se la condizione è falsa, chiamiamo l'implementazione di base del metodo ADD utilizzando la parola chiave di base.
Nel metodo principale, creiamo un oggetto di calcolo e un oggetto Customcalculation. Per prima cosa chiamiamo il metodo Aggiungi virtuale sull'oggetto di calcolo di base, passando in 5 e 7 come argomenti. Ciò dovrebbe comportare una somma di 12 e quindi chiamiamo il metodo Aggiungi sovrascritto sull'oggetto personalizzato, passando in 12 e 7 come argomenti. Ciò dovrebbe comportare una differenza di 5, poiché la somma dei due numeri è maggiore di 10.
Come puoi vedere, il metodo Aggiungi sovrascritto nella classe personalizzata viene chiamato solo quando la condizione è falsa. Quando la condizione è vera, il metodo sovrascritto fornisce un'implementazione diversa del metodo ADD che sottrae il secondo numero dal primo, sotto è l'output del codice:
Conclusione
Il metodo virtuale in C# fornisce un modo per le classi di definire metodi che possono essere personalizzati da classi derivate. Segnando un metodo come virtuale, si consentono alle classi derivate di fornire la propria implementazione del metodo e la sua è una potente caratteristica della programmazione orientata agli oggetti che consente una maggiore flessibilità e riusabilità nel codice.