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. The Dispose método do campo não é chamado pela Dispose método de tipo declarativo.

Descrição da regra

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

Como corrigir violações

Para corrigir uma violação dessa regra, telefonar Dispose em campos que são de tipos que implementam IDisposable Se você é responsável por alocar e liberar recursos não gerenciados mantido pelo campo.

Quando suprimir avisos

É seguro eliminar um aviso essa regra se você não é responsável por liberar o recurso mantido por campo, ou se a telefonar para Dispose ocorre em um nível maior de telefonar que as verificações de 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) sistema autônomo um disposable digite ()TypeA) e não chamando Dispose no campo. TypeB corresponde ao 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 Finalize e Dispose para Apagar up recursos não gerenciados

System.IDisposable