C# distruttore

Nella programmazione C#, il metodo distruttore viene utilizzato in classe per distruggere le istanze di quella particolare classe. Distruggerà quei casi della classe di cui non abbiamo bisogno in seguito. Il nome del distruttore e il nome della classe sono gli stessi. Usiamo un distruttore in una classe e una classe contiene solo un distruttore. Non possiamo ereditare o sovraccaricare un distruttore nella programmazione C#. Non è necessario chiamare il distruttore in quanto verrà invocato automaticamente. Quando esiste il nostro programma C#, allora il distruttore viene chiamato automaticamente. Abbiamo diversi esempi per comprendere questo metodo attraverso la dimostrazione pratica degli esempi.

Sintassi:

Esempio n. 1: usare Destructor nella programmazione C # in Ubuntu 20.04

In questo esempio, utilizziamo questo metodo distruttore nel nostro programma C# in Ubuntu 20.04. Ricorda una cosa; Quando scrivi questo codice sull'editor di testo di Ubuntu 20.04, devi salvare questo file con ".estensione CS ". Vediamo come funziona questo metodo distruttore nel programma C#.

Iniziamo il nostro programma C# con l'istruzione "Utilizzo del sistema". L'istruzione Utilizzo consentirà di specificare molte risorse in una dichiarazione. Qui, abbiamo "utilizzo del sistema", il che significa che utilizziamo la libreria di sistema nel nostro codice. Fornirà tutte le funzioni e le classi di cui abbiamo bisogno in questo codice. Abbiamo anche uno spazio dei nomi che ha il nome "Destructor" qui. Usiamo la parola chiave "spazio dei nomi" per organizzare il nostro codice C#.

Ora abbiamo la nostra classe principale denominata "Programma". All'interno di questa classe, stiamo creando una classe di costruttore con il nome "Programma ()". Il "Programma pubblico ()" è il nostro costruttore qui. In questo costruttore, abbiamo solo una "console.Dichiarazione WriteLine ". Potremmo usare molte affermazioni all'interno di questo costruttore. La "console.WriteLine "viene utilizzato quando si visualizza alcune informazioni o messaggi nella schermata di output. Qui, lo usiamo per visualizzare "Chiamiamo un distruttore" sullo schermo.

Dopo questo, creeremo la nostra classe di distruttore con lo stesso nome della classe di costruttore. Mettiamo il cartello "~" all'inizio della classe Destructor. La classe Destructor è chiamata "~ Programma ()" qui. Quindi, utilizziamo la funzione "principale" al di fuori della classe Destructor, che è scritta come "Public Static Void Main (String [] Args)". Qui, vediamo che è "pubblico" e "statico", e "(string [] args)" è usato in modo che i nostri valori della riga di comando siano in esso. Quindi, abbiamo questa dichiarazione "nuovo programma" in questa funzione principale; Il "nuovo" è una parola chiave che utilizziamo per creare un oggetto della classe. Visualirà prima i dati della classe del costruttore, quindi la classe Destructor si chiama automaticamente e visualizzerà anche i dati della classe Destructor. La classe Destructor distruggerà le istanze della classe quando finisce e non ha più bisogno di questi casi.

Possiamo ottenere l'output del nostro codice C# con l'aiuto dei comandi, che eseguiamo sul terminale di Ubuntu 20.04. Innanzitutto, dobbiamo compilare il nostro codice usando il comando "MCS" con il nome file che ha un'estensione di ".CS ". Quindi, dobbiamo eseguire questo programma compilato usando il comando "mono" con lo stesso nome file con un'estensione di ".exe". Ricorda che usiamo il “.Estensione del file CS "con il comando" MCS "e".Estensione del file EXE "Quando si utilizza il comando" mono ".

Questo output mostra che viene visualizzata l'affermazione all'interno della classe del costruttore e quindi la classe Destructor viene automaticamente chiamata. Viene anche visualizzata la dichiarazione di questa classe di distruttore e la classe distruttore distrugge l'istanza della classe del costruttore.

Esempio n. 2:

Ora esploreremo un altro esempio per comprendere meglio il concetto di Destructor C#. Guarda questo esempio e come funziona:

Questo codice contiene anche il "Sistema usando" e lo spazio dei nomi ", di cui abbiamo discusso in dettaglio nel nostro codice precedente. Il nome dello "spazio dei nomi" è "csharp" qui. Quindi, abbiamo una classe chiamata "Person". Questa è la nostra classe di costruttore. Stiamo dichiarando una "stringa" in questa classe di costruttore con il nome "nome". Dopo questo, abbiamo invocato il metodo "void getName ()". Il metodo "getName ()" viene utilizzato per restituire il nome del tipo di dati stringa. All'interno di questo metodo, abbiamo un'istruzione "ConsoleWriteline ()". Questa affermazione stampa i dati scritti tra le staffe di questa "console.Linea di scrittura()". Ora, abbiamo anche una classe di distruttore all'interno di questa classe di costruttore con lo stesso nome della classe di costruttore. La "~ persona ()" è la classe distruttore qui.

Dopo questo, creiamo una "console.WriteLine () "Dichiarazione in questa classe di distruttore. Successivamente, stiamo invocando un metodo al di sotto di questa classe di distruttore, che è "Public Static Void Main (String [] Args)". Abbiamo discusso in dettaglio questo metodo nel codice precedente. Ora, passiamo alla riga successiva in cui creiamo un oggetto della classe "persona" con il nome "PR". Qui, "nuovo" è una parola chiave utilizzata per la creazione di un oggetto. Nella riga successiva, abbiamo "PR.nome "," PR "è l'oggetto e il nome è la variabile del tipo di stringa che dichiariamo all'inizio del programma. Successivamente, usiamo "Nome stringa" qui. Assegniamo un nome a questo, che è "Robert Liam", e chiamiamo il metodo "getName ()" con l'oggetto della classe "PR".

L'output del nostro codice distruttore è qui in questa immagine. Guarda questo output e come visualizza i dati del nostro codice.

Puoi vederlo quando inseriamo il nome nella stringa e chiamiamo il metodo di "getName ()". Restituisce il nome usando la prima "console.Dichiarazione WriteLine ", che è scritta all'interno di questo metodo" getName () ". Quindi, il distruttore viene chiamato automaticamente e distrugge le istanze della classe del costruttore.

Esempio # 3:

Qui, stiamo esplorando un altro esempio interessante per te:

Lo "spazio dei nomi" si chiama "Mycsharprogram" qui, e la classe è chiamata "numero", che è la classe principale. Gli elementi di questa classe sono privati ​​per impostazione predefinita. Stiamo dichiarando "realnum" e "imgnum" in questa classe che è del tipo di dati "int". Dopo questo, definiremo la classe del costruttore con il nome "numero ()" e inizializzeremo questi numeri interi precedenti qui.

Quindi, abbiamo un metodo SetValue utilizzato per impostare i valori di "Realnum" e "Imgnum". Assegniamo "rnum" a "realnum" e "inum" a "imgnum" all'interno di questo metodo. Stiamo creando un altro metodo chiamato "DisplayValue", che visualizzerà i valori di entrambi i numeri interi usando la "console.WriteLine () ”Dichiarazione. Dopodiché, creiamo una classe di distruttore al di fuori di questo metodo.

Il "~ numero ()" è la classe Destructor qui. Abbiamo anche una "console.WriteLine () "all'interno di questa classe di distruttore. Quindi, abbiamo una classe di driver denominata "Programma". Creiamo un metodo "principale" e quindi creiamo un oggetto "N" di "numero" di classe con l'aiuto della "nuova" parola chiave. Questo oggetto "N" invoca il costruttore. Quindi, chiamiamo il metodo "setValue ()" e passiamo i valori a questo metodo. Nella riga successiva, viene chiamato il metodo "DisplayValue ()", che visualizzerà i valori di "Realnum" e "Imgnum".

Quando viene chiamato il costruttore, i metodi all'interno del costruttore vengono eseguiti nell'output. Il metodo "setvalue" imposta i valori di "realnum" e "imgnum", quindi il "displaymethod" visualizza i valori di entrambi i numeri. Qui, il distruttore distrugge questi oggetti in quanto non sono necessari in seguito e stampa la dichiarazione scritta all'interno del distruttore. In altre parole, il distruttore viene chiamato qui automaticamente.

Conclusione:

In questa guida, esploriamo il concetto di distruttore nella programmazione C# in Ubuntu 20.04. Veniamo a sapere che il distruttore nella programmazione C# viene utilizzato per la distruzione delle istanze della classe del costruttore quando non abbiamo bisogno di tali istanze in seguito. Spieghiamo in dettaglio questo concetto di distruttore. E inoltre, fornisci diversi esempi con il loro output per te in modo da provare questi esempi da soli e avere l'idea di questo concetto. Spieghiamo in dettaglio ogni riga di questo codice C# per la tua comprensione. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.