Introduction à Destructor en C #
Dans l'article Destructor en C # comme son nom l'indique, les destructeurs sont les méthodes en C # qui détruisent les objets. Si les objets ne sont plus nécessaires, le destructeur est appelé pour détruire ces objets de la classe. Le destructeur invoquera automatiquement par le garbage collector et détruit les objets.
Syntaxe:
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();
)
)
Le destructeur est représenté par ~ (tilde).
Propriétés de Destructor en C #
Voici les propriétés du destructeur:
- Les destructeurs ne peuvent pas avoir de paramètres et de modificateurs d'accès.
- Chaque classe ne doit comprendre qu'un seul destructeur.
- Les destructeurs ne peuvent pas être surchargés ou hérités.
- Le nom du destructeur est toujours le même que le nom de la classe et n'a pas de type de retour.
- Destructor utilise la méthode Finalize et invoquée par Garbage Collector lorsque les objets ne sont plus nécessaires.
- Destructor suit le modèle inverse. Dans destructor, la classe dérivée est appelée d'abord, puis la classe de base.
Comment fonctionne Destructor en C #?
Voici quelques exemples qui montrent comment cela fonctionne en C #.
Exemple 1
Code:
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());
)
)
)
Dans l'exemple ci-dessus, le constructeur paramétré est initialisé avec le nom et l'âge du paramètre où il s'agit d'un mot-clé faisant référence aux variables de classe. Après ce destructeur est créé avec le même nom que le nom de classe et le symbole ~. Dans la méthode principale, il y a un objet de l'élève. Après avoir obtenu le nom et l'âge d'une personne, les objets ne sont plus nécessaires. On appelle donc destructeur qui détruit les objets et désalloue leurs mémoires.
Production:
Exemple # 2
Code:
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());
)
)
)
Cet exemple est presque le même que l'exemple précédent, mais dans cet exemple, il existe deux objets dans la méthode principale. Comme nous le savons, le constructeur s'exécute pour chaque objet et cette même chose s'applique également au destructeur. Dans ce cas, le destructeur est appelé deux fois et désalloue la mémoire de chaque objet.
Production:
Exemple # 3
Code:
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();
)
)
)
Dans l'exemple ci-dessus, la classe parent est définie et possède un destructeur. Ensuite, la classe enfant hérite de la classe parent et se compose également d'un destructeur. Ainsi, le destructeur enfant appelle automatiquement le destructeur de base.
Dans les constructeurs, le constructeur de base est appelé en premier. Par exemple, si nous avons la classe de base A qui est héritée par la classe B, donc dans le cas du constructeur, la classe A est appelée d'abord, puis la classe B.Cependant, dans le cas du destructeur, la classe B (classe dérivée) est appelée avant la classe A ( classe de base).
Un autre exemple d'exécution d'ordres: -
Code:
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();
)
)
)
Production:
Comme vous pouvez le voir, le troisième constructeur est appelé initialement suivi du second et du premier.
Exemple # 4
Code:
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();
)
)
)
Production:
Destructor désalloue la mémoire de l'objet si elles ne sont pas nécessaires à la fin du programme. Mais parfois, si nous utilisons GC.Collect () au milieu de l'exécution du programme, il détruira les objets au milieu et désallouera la mémoire de ces objets. Le destructeur peut être appelé implicitement ou explicitement. Mais il n'est pas nécessaire de détruire les objets explicitement car C # fournit la collecte des ordures. Cependant, lorsque vous avez terminé avec les ressources non gérées, vous devrez les libérer explicitement. Il n'est pas nécessaire d'appeler ou de cas de ressources gérées. Utilisez le destructeur pour gérer les ressources non gérées. Garbage Collector appellera destructeur car il se compose d'une liste d'objets qui ont un destructeur. Ainsi, chaque fois qu'un objet est créé ou détruit, cette liste est mise à jour. S'il y a un objet dans la file d'attente, il est collecté par le garbage collector après l'exécution du destructeur.
Conclusion
Le principal objectif du destructeur est de libérer la mémoire des objets après leur exécution. Il existe donc différentes actions exécutées dans le destructeur, telles que la récupération de l'espace, la libération des ressources réseau et des verrous de ressources, etc. Les destructeurs doivent être utilisés pour libérer des ressources non gérées plutôt que des ressources gérées.
Article recommandé
Cela a été un guide pour Destructor en C #. Ici, nous discutons de l'introduction, des propriétés ainsi que des exemples de destructeur en C #. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Introduction à Destructor en Java
- Héritage en C # | 4 principaux types
- Copier le constructeur en C # (exemples)
- Qu'est-ce que le multithreading en C #? | Les avantages
- Destructeur en Python (Avantages avec l'exemple)
- Modificateurs d'accès en PHP
- Types de constructeur en C # avec implémentation de code
- Création et méthodes de multithreading en C #