Quelle est la différence entre un constructeur et un destructeur en C #?


Réponse 1:

C # n'a pas de destructeurs, il a des finaliseurs, ce qui est différent.

Essentiellement, un constructeur est ce qu’on appelle le mot-clé «nouveau» et dans les langages qui en disposent, les destructeurs sont appelés par le mot-clé «supprimer» (ou lorsque l’objet sort du cadre).

Un finaliseur, d'autre part, est appelé par le garbage collector _ quelque temps après_ que l'objet s'éteigne ou s'étende (techniquement lorsqu'il n'y a plus de pointeurs vers lui qui ne sont pas également "hors de portée").

Deux choses importantes à noter sur les finaliseurs:

  • Vous n'avez aucun moyen de savoir exactement quand il sera appelé Vous devez faire attention à ce que vous faites dans un finaliseur - d'autres objets de la même classe peuvent déjà avoir été récupérés. Vous ne devez toucher que les références non gérées dans un Finalizer.

Si vous voulez / avez besoin de quelque chose de plus proche d'un destructeur en C #, vous avez l'interface IDisposable, qui fournit une méthode; "Disposer".

C # a un mot clé spécial «using», qui déclare un objet dans une étendue et garantit que la méthode Dispose est appelée.

Cette méthode doit également disposer de tous les objets IDisposable appartenant à la classe implante.

Si votre classe contient des objets non gérés, vous devez créer une surcharge de la méthode Dispose qui prend un paramètre booléen. Cette méthode doit supprimer toutes les références non mélangées, et si le paramètre bool est vrai, elle doit également supprimer tous les objets IDisposable. Vous devez ensuite créer un finaliseur, qui appelle Dispose (false) pour garantir que les ressources non gérées sont libérées au cas où la méthode dispose n'a jamais été appelée. Le Dispose normal doit appeler Dispose (true), et également appeler GC.SurpressFinalize (), car la finalisation ne sera pas nécessaire (cela garantit que l'objet est récupéré plus rapidement et permet d'éviter les erreurs dans le finaliseur)


Réponse 2:

Le constructeur et le destructeur sont des fonctions membres spéciales de classe dans tous les langages de programmation comme c # ou Java. La fonction de ces membres a le même nom que le nom de la classe et est invoquée lorsque nous créons un objet d'une classe.

Fondamentalement, le constructeur est utilisé pour initialiser les membres de données d'une classe et le destructeur est utilisé pour détruire les objets ou libérer les mémoires occupées par l'objet.

Une utilisation en temps réel du constructeur consiste à initialiser les membres de données avec des valeurs par défaut et c'est pourquoi nous avons un constructeur par défaut.

Par exemple, chaque fois que nous créons des e-mails de n'importe quel domaine comme Gmail, Yahoo ou Microsoft, nous recevons des e-mails par défaut dans notre boîte de réception, ce qui signifie que ces e-mails sont des valeurs par défaut.

Pour mieux le comprendre, considérez Gmail comme une classe.

classe Gmail
{
 message chaîne;
 Gmail public (chaîne Nom d'utilisateur)
 {
   message = "bienvenue dans Gmail" + nom d'utilisateur
 }
}
En fonction principale
Gmail g1 = nouveau Gmail («Shinchan.gupta»);
Gmail g2 = nouveau Gmail ("aching.gupta");

Maintenant, chaque fois que nous allons créer un nouvel identifiant de messagerie, cela signifie que nous créons un nouvel objet de Gmail. Et cela initialisera les membres des données de message avec des valeurs par défaut pour tous les objets et c'est pourquoi chaque utilisateur de gmail reçoit le même message dans la boîte de réception et quel est le courrier par défaut que vous pouvez dire.

Maintenant, nous avons créé deux objets et il contient l'allocation de mémoire qui doit être libérée une fois le programme exécuté et pour cela nous avons un destructeur qui est également appelé automatiquement et détruit les objets pour libérer la mémoire.

En termes simples, lorsque vous utilisez le constructeur, il alloue de la mémoire et lorsque vous utilisez le destructeur, il libère la mémoire allouée.