Destructeur en C#

Dans l'article Destructeur 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 sera automatiquement invoqué par le garbage collector et détruira les objets.

Syntaxe :

class Demo
{
// other methods
~Demo()  // destructor
{
// your code
}
}

Le destructeur C# est un raccourci de la méthode Finalize(). Alors quand tu déclares un destructeur

~Demo()   // destructor
{
// your code
}

Le compilateur C# le traduira en :

protected override void Finalize()
{
try
{
// your code
}
finally
{
base.Finalize();
}
}

Le destructeur est représenté par ~ (tilde).

Propriétés du Destructeur en C#

Voici les propriétés du destructeur :

1. Les destructeurs ne peuvent avoir aucun paramètre ni modificateur d'accès.
2. Chaque classe ne doit être composée que d'un seul destructeur.
3. Les destructeurs ne peuvent pas être surchargés ou hérités.
4. Le nom du destructeur est toujours le même que le nom de la classe et n'a pas de type de retour.
5. Destructor utilise la méthode Finalize et est invoqué par Garbage Collector lorsque les objets ne sont plus nécessaires.
6. Destructor suit le modèle inverse. Dans le destructeur, 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 n°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 la classe et le symbole ~. Dans la méthode principale, il y a un objet de la classe personne. Après avoir obtenu le nom et l’âge d’une personne, les objets ne sont plus nécessaires. Un destructeur est donc appelé, qui détruit les objets et désalloue leurs mémoires.

Sortie :

Exemple n°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 y a 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.

Sortie :

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 en premier, puis la classe B. Cependant, dans le cas du destructeur, la classe B (classe dérivée) est appelée en premier avant la classe A ( classe de base).

Un autre exemple d'exécution d'ordre :-

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();
}
}
}

Sortie :

Comme vous pouvez le voir, le troisième constructeur est appelé initialement suivi du deuxième et du premier.

Exemple n°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();
}
}
}

Sortie :

Destructor désalloue la mémoire de l'objet s'il n'est pas requis à la fin du programme. Mais parfois, si nous utilisons GC.Collect() au milieu de l'exécution d'un programme, cela 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 explicitement les objets car C# fournit un garbage collection. Cependant, lorsque vous en aurez terminé avec les ressources non gérées, vous devrez les libérer explicitement. Il n'est pas nécessaire d'appeler ou de gérer des ressources. Utilisez le destructeur pour gérer les ressources non gérées. Un garbage Collector appellera un destructeur car il consiste en 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 but principal du destructeur est de libérer la mémoire des objets après leur exécution. Il y a donc différentes actions exécutées dans le destructeur comme 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é

Ceci a été un guide sur Destructor en C#. Nous discutons ici 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 –

1. Destructeur en Java
2. Héritage en C#
3. Copier le constructeur en C# 
4. Destructeur en Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!