CA2213: Verwerfbare Felder verwerfen

Ursache

Ein Typ, der System.IDisposable implementiert, deklariert Felder, die Typen aufweisen, die ebenfalls IDisposable implementieren.Die Dispose-Methode des Felds wird nicht von der Dispose-Methode des deklarierenden Typs aufgerufen.

Regelbeschreibung

Ein Typ muss all seine nicht verwalteten Ressourcen freigeben (verwerfen). Dies wird durch die Implementierung von IDisposable erreicht.Mit dieser Regel wird überprüft, ob ein verwerfbarer Typ T ein Feld F deklariert, das eine Instanz eines verwerfbaren Typs FT ist.Für jedes Feld F versucht die Regel, einen Aufruf von FT.Dispose zu finden.Die Regel durchsucht die von T.Dispose aufgerufenen Methoden und die Ebene darunter (also die Methoden, die von FT.Dispose aufgerufen wurden).

Behandeln von Verstößen

Wenn Sie für die Zuordnung und Freigabe der im Feld gespeicherten nicht verwalteten Ressourcen zuständig sind, beheben Sie einen Verstoß gegen diese Regel, indem Sie Dispose für Felder aufrufen, die typbedingt IDisposable implementieren.

Wann sollten Warnungen unterdrückt werden?

Eine Warnung dieser Regel kann gefahrlos unterdrückt werden, wenn Sie nicht für die Freigabe der Ressourcen verantwortlich sind, die im Feld gespeichert sind, oder wenn der Aufruf von Dispose in einer Ebene unterhalb der Regelüberprüfung erfolgt.

Beispiel

Im folgenden Beispiel wird ein Typ gezeigt (TypeA), der IDisposable (FT im vorherigen Beispiel) implementiert.

using System;  

namespace UsageLibrary
{
    public class  TypeA :IDisposable
    {

        protected virtual void Dispose(bool disposing) 
        {
            if (disposing) 
            {
                // Dispose managed resources
            }

            // Free native resources
        }

        public void Dispose()
        {

                Dispose(true);

                GC.SuppressFinalize(this);

        }

        // Disposable types implement a finalizer.
        ~TypeA()
        {
            Dispose(false);
        }
    }
}

Im folgenden Beispiel verstößt ein Typ (TypeB) gegen diese Regel, da ein Feld aFieldOfADisposableType (F in der vorherigen Diskussion) als verwerfbarer Typ (TypeA) deklariert und Dispose im Feld nicht aufgerufen wird.TypeB entspricht T in der vorherigen Diskussion.

using System;  

namespace UsageLibrary
{
   public class  TypeB : IDisposable
   {
      // Assume this type has some unmanaged resources.
      TypeA aFieldOfADisposableType = new TypeA();
      private bool disposed = false;

      protected virtual void Dispose(bool disposing) 
      {
         if (!disposed) 
         {
            // Dispose of resources held by this instance.

            // Violates rule: DisposableFieldsShouldBeDisposed.
            // Should call aFieldOfADisposableType.Dispose();

            disposed = true;
             // Suppress finalization of this disposed instance.
             if (disposing)
             {
                 GC.SuppressFinalize(this);
             }
         }
      }

      public void Dispose()
      {
         if (!disposed)
         {
            // Dispose of resources held by this instance.
            Dispose(true);
         }
      }

      // Disposable types implement a finalizer.
      ~TypeB()
      {
         Dispose(false);
      }
   }
}

Siehe auch

Referenz

Implementing Finalize and Dispose

System.IDisposable