Quand est-ce que la méthode d'élimination ne serait pas appelée?

Question

Je lisais l'article this l'autre jour et je me demandais pourquoi il y avait un Finalizer avec la méthode Dispose. J'ai lu here sur SO pour savoir pourquoi vous pourriez vouloir ajouter Dispose au Finalizer. Ma curiosité est de savoir quand le Finalizer sera appelé par-dessus la méthode Dispose elle-même? Existe-t-il un exemple de code ou est-ce basé sur quelque chose qui se passe sur le système que le logiciel exécute? Si c'est le cas, qu'est-ce qui pourrait arriver à ce que la méthode Dispose ne soit pas exécutée par le GC?

Answer 1

Le but du finaliser ici est simplement une mesure de sécurité contre les fuites de mémoire (si vous vous trouvez pas pour appeler explicitement Dispose). Cela signifie également que vous n'avez pas à disposer de vos objets si vous voulez qu'ils libèrent des ressources lorsque le programme s'arrête, car le GC sera forcé de finaliser et de collecter tous les objets de toute façon.

Par ailleurs, il est important de disposer l'objet légèrement différemment à partir du finaliseur.

~MyClass() 
{ 
    Dispose(false); 
} 

public void Dispose() 
{ 
    Dispose(true); 
    GC.SuppressFinalize(this); 
} 

protected void Dispose(disposing) 
{ 
    if (!this.disposed) 
    { 
     if (disposing) 
     { 
      // Dispose managed resources here. 
     } 
     // Dispose unmanaged resources here. 
    } 
    this.disposed = true; 
} 

La raison pour laquelle vous ne veulent disposer des ressources gérées dans votre Finaliser est que vous REELLEMENT créer de solides références à eux en faisant, et cela pourrait empêcher le GC de le faire est le travail correctement et la collecte leur. Les ressources non managées (par exemple les poignées Win32 et autres) doivent toujours être explicitement fermées/éliminées, bien sûr, puisque le CLR n'en a aucune connaissance.

Answer 2

Ceci est principalement là pour vous protéger. Vous ne pouvez pas dicter ce que fera l'utilisateur final de votre classe. En fournissant un finaliseur en plus d'une méthode Dispose, le GC va "Disposer" de votre objet, libérant vos ressources de manière appropriée, même si l'utilisateur oublie d'appeler Dispose() ou utilise mal votre classe.

Answer 3

La méthode dispose doit être explicitement appelée, soit en appelant Dispose() ou en ayant l'objet dans une instruction using. Le GC appellera toujours le finaliseur, donc s'il y a quelque chose qui doit arriver avant que les objets soient éliminés, le finaliseur devrait au moins vérifier pour s'assurer que tout dans l'objet est nettoyé. Vous voulez éviter de nettoyer les objets dans le finaliseur, dans la mesure du possible, car cela nécessite un travail supplémentaire comparé à la disposition préalable (comme l'appel), mais vous devez toujours au moins vérifier le finaliseur s'il y a des objets traînant autour de ce besoin d'être enlevé.

Answer 4

Le Finalizer est appelé lorsque l'objet est collecté. Dispose doit être appelé explicitement. Dans le code suivant, le finaliseur sera appelé mais la méthode Dispose ne l'est pas.

class Foo : IDisposable 
{ 
    public void Dispose() 
    { 
    Console.WriteLine("Disposed"); 
    } 

    ~Foo() 
    { 
    Console.WriteLine("Finalized"); 
    } 
} 

... 

public void Go() 
{ 
    Foo foo = new Foo(); 
} 

Answer 5

Une note subtile, mais importante pas encore mentionné: un but de Dispose rarement considéré est d'empêcher un objet d'être nettoyé prématurément. Les objets avec les finaliseurs doivent être écrits avec soin, sinon un finaliseur plus tôt que prévu. Un finalizer ne peut pas s'exécuter avant le début du dernier appel de méthode qui sera effectué sur un objet (*), mais il peut parfois exécuter pendant le dernier appel de méthode si l'objet est abandonné une fois la méthode terminée. Le code qui détruit correctement un objet ne peut pas abandonner l'objet avant d'appeler Dispose, il n'y a donc aucun risque qu'un finaliseur fasse des ravages sur du code qui utilise correctement Dispose. D'autre part, si la dernière méthode d'utilisation d'un objet utilise des entités qui seront nettoyées dans le finaliseur après sa dernière utilisation de la référence d'objet elle-même, il est possible que garbage-collector appelle Finalize sur l'objet et nettoie des entités qui sont encore utilisées.Le remède consiste à s'assurer que toute méthode d'appel qui utilise des entités qui vont être nettoyées par un finaliseur doit être suivie à un certain moment par un appel de méthode qui utilise "this". GC.KeepAlive (this) est une bonne méthode à utiliser pour cela. (*) Les méthodes non virtuelles qui sont étendues au code en ligne qui ne fait rien avec l'objet peuvent être exemptées de cette règle, mais Dispose est généralement une méthode virtuelle.