Entsorgen der Mitglieder, die IDisposable implementieren

Question

In meinen Dispose-Methoden (wie die unten), jedes Mal, wenn ich SomeObj.Dispose() aufrufen möchte, habe ich auch eine Überprüfung für someObj! = Null.

Ist das wegen schlechten Designs meinerseits? Ist es ein saubererer Weg, sicherzustellen, dass Dispose von allen Mitgliedern (die IDisposable implementieren), die in einem Objekt verwendet werden, aufgerufen wird, ohne ein Risiko der NullReference-Ausnahme zu haben?

protected void Dispose(bool disposing) 
     { 
      if (disposing) 
      { 
       if (_splitTradePopupManager != null) 
       { 
        _splitTradePopupManager.Dispose(); 
       } 
      } 
     } 

Vielen Dank für Ihr Interesse.

Answer 1

Vielleicht hat jemand anderes läuten kann in diesem, aber ich persönlich denke nicht, dass es ein Designfehler ist - nur der sicherste Weg, es zu tun.

Das heißt, ist nichts mehr im Wege stehen Ihre null Prüfung und Dispose Anruf in einer bequemen Methode Verpackung:

protected void Dispose(bool disposing) 
{ 
    if (disposing) 
    { 
     DisposeMember(_splitTradePopupManager); 
     DisposeMember(_disposableMember2); 
     DisposeMember(_disposableMember3); 
    } 
} 

Als zusätzlichen:

private void DisposeMember(IDisposable member) 
{ 
    if (member != null) 
     member.Dispose(); 
} 

Dann wird Ihr Dispose Methode ein wenig sauberer aussehen könnte Bonus, dies löst auch eine mögliche Race-Bedingung in Ihrem ursprünglichen Code. Bei Ausführung in einem Multithread-Kontext kann das Muster if (_field != null) _field.Dispose() zu einem NullReferenceException führen, wenn _field zwischen der Überprüfung und der Entsorgung auf null gesetzt ist (selten, aber möglich). Übergeben _field als ein Argument für eine Methode wie DisposeMember kopiert den Verweis auf eine lokale Variable in der Methode, diese Möglichkeit zu eliminieren, unwahrscheinlich wie es ist.

Answer 2

Nur Sie kennen die Antwort auf dieses!

Ohne Ihre gesamte Klasse zu sehen, ist es für jeden anderen schwierig zu sagen, ob es möglich ist, dass diese Mitglieder jemals null sein werden, wenn aufgerufen wird.

(Natürlich in der Regel möglich, es ist immer für ein Referenztyp oder Nullable-Wertetyp null zu sein, so ist es wahrscheinlich eine gute Praxis immer die Null-Kontrollen sowieso, umfassen.)

Answer 3

Die einzige andere Option, die ich mir vorstellen könnte wäre, eine DisposeParameter Hilfsmethode zu erstellen, die ein Objekt als Parameter hat und nur prüft, ob es null ist und ansonsten Dispose. Auf diese Weise benötigen Sie nur eine Codezeile, um darüber zu verfügen, aber ich bin mir nicht sicher, ob es dadurch lesbarer wird.

Answer 4

Versuchen Sie es.

protected void Dispose(bool disposing) 
    { 
     if (disposing) 
     { 
      //for all members.. 
      if (null != member && member is IDisposible) 
      { 
       member.Dispose(); 
      } 
     } 
    } 

Answer 5

Ich mag @ Dan Tao-Lösung, aber es ist viel besser als eine Erweiterung Methode, imo:

public static void SafeDispose(this IDisposable obj) 
{ 
    if (obj != null) 
     obj.Dispose(); 
} 

Jetzt können Sie nur member.SafeDispose() für ein beliebiges IDisposable in Ihrem Programm, ohne Sorgen. :)