CA2213: Campos descartáveis devem ser descartados

Artigo
02/25/2013

TypeName	DisposableFieldsShouldBeDisposed
CheckId	CA2213
<strong>Categoria</strong>	Microsoft.Usage
Alteração significativa	Não separável

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 é conseguido com a implementação de 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 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, chame Dispose em campos que são de tipos que implementam IDisposable se você é responsável por alocar e liberar os recursos não gerenciados mantido 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 de chamada mais profundo 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) como um tipo descartável (TypeA) e não chamando Dispose no campo.TypeBcorresponde à 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

Implementing Finalize and Dispose

System.IDisposable

Compartilhar via