CA2213: Campos descartáveis devem ser descartados.

Causa

Um tipo que implementa System.IDisposable declara os campos que são de tipos que implementam também IDisposable. O Dispose o método do campo não é chamado pelo Dispose o método do tipo declarativo.

Descrição da regra

Um tipo é responsável pela eliminação de todos os seus recursos não gerenciados; Isso é realizado pela implementação IDisposable. Esta regra verifica se um tipo descartável T declara um campo F ou seja, uma instância de um tipo descartável FT. Para cada campo F, a regra para tenta localizar uma chamada para FT.Dispose. A regra procura os métodos chamados por T.Disposee um nível inferior (os métodos chamados pelos métodos chamados por FT.Dispose).

Como corrigir violações

Para corrigir uma violação desta regra, chamada Dispose em campos que são de tipos que implementam IDisposable se você é responsável por alocar e liberar os recursos não gerenciados, mantidos pelo campo.

Quando suprimir avisos

É seguro eliminar um aviso esta regra, se você não é responsável por liberar o recurso mantido pelo campo, ou se a chamada para Dispose ocorre em um nível mais profundo de chamada verificações da regra.

Exemplo

O exemplo a seguir mostra um tipo de TypeA que implementa IDisposable (FT na discussão previosu).

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);
        }
    }
}

O exemplo a seguir mostra um tipo de TypeB que viola essa regra, declarando um campo aFieldOfADisposableType (F na discussão anterior) como um tipo descartável (TypeA) e não chamando Dispose no campo. TypeBcorresponde a T na discussão anterior.

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);
      }
   }
}

Consulte também

Referência

Implementando finalizar e Dispose para limpeza de recursos não gerenciados

System.IDisposable