Introduzione a Destructor in C #
Nell'articolo Destructor in C # come suggerisce il nome, i distruttori sono i metodi in C # che distruggono gli oggetti. Se gli oggetti non sono più necessari, viene chiamato il distruttore per distruggere quegli oggetti dalla classe. Il distruttore invocherà automaticamente il garbage collector e distruggerà gli oggetti.
Sintassi:
class Demo
(
// other methods
~Demo() // destructor
(
// your code
)
)
C# destructor is a shortcut of Finalize( ) method. So when you declare destructor
~Demo() // destructor
(
// your code
)
C# compiler will translate it to:
protected override void Finalize()
(
try
(
// your code
)
finally
(
base.Finalize();
)
)
Il distruttore è rappresentato da ~ (tilde).
Proprietà del distruttore in C #
Le seguenti sono le proprietà del distruttore:
- I distruttori non possono avere parametri e modificatori di accesso.
- Ogni classe dovrebbe essere composta da un solo distruttore.
- I distruttori non possono essere sovraccaricati o ereditati.
- Il nome del distruttore è sempre uguale al nome della classe e non ha tipo di ritorno.
- Destructor utilizza il metodo Finalize e invocato da Garbage Collector quando gli oggetti non sono più necessari.
- Il distruttore segue il modello inverso. Nel distruttore, la classe derivata viene chiamata prima e poi classe base.
Come funziona Destructor in C #?
Ecco alcuni esempi che mostrano come funziona in C #.
Esempio 1
Codice:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class person
(
//variables
public string name;
public int age;
public person(string name, int age) //parametrized constructor
(
this.name = name;
this.age = age;
)
public string getName()
(
return this.name;
)
public int getAge()
(
return this.age;
)
~person() // destructor
(
Console.WriteLine("Destructor has been invoked");
)
)
class Program
(
// main method
static void Main(string() args)
(
person Details = new person("Joe", 28);
Console.WriteLine(Details.getName());
Console.WriteLine(Details.getAge());
)
)
)
Nell'esempio sopra, il costruttore con parametri è inizializzato con il nome e l'età del parametro in cui si tratta di una parola chiave che fa riferimento a variabili di classe. Dopo che il distruttore viene creato con lo stesso nome del nome e del simbolo della classe ~. Nel metodo principale, c'è un oggetto della persona di classe. Dopo aver ottenuto il nome e l'età di una persona, gli oggetti non sono più necessari. Si chiama così distruttore che distrugge gli oggetti e disalloca i loro ricordi.
Produzione:
Esempio n. 2
Codice:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
anmespace Destructor
(
class person
(
// variables
public string name;
public int age;
public person(string name, int age) // parameterized constructor
(
this.name = name;
this.age = age;
)
public string getName()
(
return this.name;
)
public int getAge()
(
return this.age;
)
~person() //destructor
(
Console.WriteLine("Descructor has been invoked");
)
)
class Program
(
// Main method
static void Main(string() args)
(
person Details = new person("Joe", 28); // first object
person Details1 = new person("John", 20);
Console.WriteLine(Details.getName());
Console.WriteLine(Details.getAge());
Console.WriteLine(Details1.getName());
Console.WriteLine(Details1.getAge());
)
)
)
Questo esempio è quasi uguale all'esempio precedente, ma in questo esempio ci sono due oggetti nel metodo principale. Come sappiamo, il costruttore funziona per ogni oggetto e questa stessa cosa viene applicata anche al distruttore. In questo caso, il distruttore viene chiamato due volte e disalloca la memoria di ciascun oggetto.
Produzione:
Esempio n. 3
Codice:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
public class Parent
(
~Parent() // base destructor
(
Console.WriteLine("Parent.~Parent()");
)
)
public class Child : Parent
(
~Child() // derived destructor
(
Console.WriteLine("Child.~Child()");
)
)
public class MainClass
(
static void Main()
(
Child child = new Child();
)
)
)
Nell'esempio sopra, viene definita la classe genitore che ha un distruttore. Quindi la classe figlio eredita la classe genitore ed è composta anche da un distruttore. Quindi il distruttore figlio chiama automaticamente il distruttore base.
Nei costruttori, il costruttore di base viene chiamato per primo. Ad esempio, se abbiamo una classe base A che è ereditata dalla classe B, quindi nel caso del costruttore la classe A viene chiamata prima e poi la classe B. Tuttavia, nel caso del distruttore la classe B (classe derivata) viene chiamata prima della classe A ( classe di base).
Un altro esempio di esecuzione dell'ordine: -
Codice:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class Tree
(
~Tree()
(
System.Console.WriteLine("This is the first destructor");
)
)
class Branch: Tree
(
~Branch()
(
System.Console.WriteLine("This is the second destructor");
)
)
class Flower: Branch
(
~Flower()
(
System.Console.WriteLine("This is the third destructor");
)
)
class Test
(
static void Main()
(
Flower f= new Flower();
)
)
)
Produzione:
Come puoi vedere, il terzo costruttore viene chiamato inizialmente seguito dal secondo e dal primo.
Esempio n. 4
Codice:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class Example
(
public Example()
(
// constructor
Console.WriteLine("Object Created");
)
// Destructor
~Example()
(
Console.WriteLine("Object Destroyed");
)
)
class Program
(
public static void Sample()
(
Example ex = new Example();
)
static void Main(string() args)
(
Sample();
GC.Collect();
Console.ReadLine();
)
)
)
Produzione:
Il distruttore disalloca la memoria dell'oggetto se non è richiesto alla fine del programma. Ma a volte se usiamo GC.Collect () nel mezzo dell'esecuzione del programma, distruggerà gli oggetti nel mezzo e disallocare la memoria di quegli oggetti. Il distruttore può essere chiamato implicitamente o esplicitamente. Ma non è necessario distruggere esplicitamente gli oggetti poiché C # fornisce la garbage collection. Tuttavia, quando hai finito con le risorse non gestite, dovrai liberarle esplicitamente. Non è necessario chiamare o caso di risorse gestite. Utilizzare il distruttore per la gestione delle risorse non gestite. Garbage Collector chiamerà distruttore in quanto è costituito da un elenco di oggetti che hanno un distruttore. Pertanto, ogni volta che un oggetto viene creato o distrutto, tale elenco viene aggiornato. Se nella coda è presente un oggetto, questo viene raccolto dal Garbage Collector dopo l'esecuzione del distruttore.
Conclusione
Lo scopo principale del distruttore è liberare la memoria degli oggetti dopo la loro esecuzione. Esistono quindi diverse azioni eseguite nel distruttore come il recupero dello spazio, il rilascio di risorse di rete e blocchi di risorse, ecc. I distruttori dovrebbero essere usati per rilasciare risorse non gestite anziché risorse gestite.
Articolo raccomandato
Questa è stata una guida a Destructor in C #. Qui discutiamo l'introduzione, le proprietà e gli esempi di distruttore in C #. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Introduzione a Destructor in Java
- Eredità in C # | I 4 migliori tipi
- Copia costruttore in C # (esempi)
- Che cos'è il multithreading in C #? | vantaggi
- Destructor in Python (Vantaggi con esempio)
- Modificatori di accesso in PHP
- Tipi di costruttore in C # con implementazione del codice
- Creazione e metodi di multithreading in C #