Comment puis-je gérer toutes les exceptions dans une classe C# où les deux ctor et finalizer jeter des exceptions?

Question

Comment puis-je gérer toutes les exceptions pour une classe similaire au suivant dans certaines circonstances?

class Test : IDisposable { 
    public Test() { 
    throw new Exception("Exception in ctor"); 
    } 
    public void Dispose() { 
    throw new Exception("Exception in Dispose()"); 
    } 
    ~Test() { 
    this.Dispose(); 
    } 
} 

J'ai essayé, mais ça ne marche pas:

static void Main() { 
    Test t = null; 
    try { 
    t = new Test(); 
    } 
    catch (Exception ex) { 
    Console.Error.WriteLine(ex.Message); 
    } 

    // t is still null 
} 

J'ai aussi essayé d'utiliser « en utilisant » mais il ne gère pas l'exception levée de ~ Test();

static void Main() { 
    try { 
    using (Test t = new Test()) { } 
    } 
    catch (Exception ex) { 
    Console.Error.WriteLine(ex.Message); 
    } 
} 

Des idées comment puis-je contourner?

Answer 1

Tout d'abord, un Finalizer devrait jamais jeter une exception. Si c'est le cas, quelque chose est devenu catastrophique et l'application devrait planter dur. Un Finalizer ne devrait jamais appeler Dispose() directement. Les finaliseurs servent uniquement à libérer des ressources non gérées, car les ressources gérées peuvent ne pas être dans un état valide une fois que le Finalizer est exécuté. Les références gérées seront déjà nettoyées par le garbage collector, il vous suffit donc de les éliminer dans votre Dispose, pas dans votre Finalizer. Cela dit, une exception dans Dispose doit être interceptée si vous appelez Dispose explicitement. Je ne comprends pas très bien comment le cas 'using' n'a pas jeté l'exception. Cela dit, Dispose ne devrait pas non plus être une exception, si vous pouvez l'éviter. En particulier, un Dispose qui lance une exception après un bloc using écrase toute exception qui pourrait survenir dans le bloc using avec l'exception Dispose.

---

Certains documents de référence supplémentaires here

Answer 2

Je pense qu'une partie de la réponse est que vous ne devriez pas gérer les exceptions dans ces cas.

Vous ne devriez attraper des exceptions que si vous pouvez les récupérer, ou si vous pouvez ajouter des informations supplémentaires à l'exception et les relancer. Vous ne devriez pas attraper toutes les exceptions. Laissez le code plus haut dans la pile d'appels gérer autant d'exceptions que possible.

Answer 3

J'ai quelques observations. Tout d'abord, évitez de lancer des exceptions à partir de Dispose. En fait, j'irais presque jusqu'à dire jamais. Les développeurs .NET ont été conditionnés à s'attendre à ce que Dispose réussisse toujours et pour de bonnes raisons. Il serait maladroit d'emballer l'appel en essayant à chaque fois et cela réduirait certainement la lisibilité. Deuxièmement, et ceci fait l'objet d'un débat fréquent, évitez de lancer des exceptions aux constructeurs. Les exceptions liées à la validation d'un état tel que ArgumentException ou IndexOutOfRangeException sont correctes car elles sont généralement générées en raison de violations de pré-condition et sont généralement le résultat d'une erreur de programmation. Mais, des exceptions imprévisibles telles que SqlException forceraient un appelant à envelopper le constructeur dans un bloc try-catch. Encore une fois, cela conduit à des scénarios de codage maladroits. Mais, plus important encore, cela peut entraîner des fuites de ressources subtiles dans les scénarios où le constructeur alloue des ressources non gérées puis lève une exception avant de renvoyer la nouvelle instance à l'appelant. Sans la référence d'instance, l'appelant ne peut pas appeler Dispose.