CA2213: Aplique Dispose a los campos a los que se pueda

Nombre de tipo	DisposableFieldsShouldBeDisposed
Identificador de comprobación	CA2213
Categoría	Microsoft.Usage
Cambio problemático	No

Causa

Un tipo que implementa System.IDisposable declara campos que son de tipos que también implementan IDisposable. El método Dispose del tipo declarado no llama al método Dispose del campo.

Descripción de la regla

Un tipo es responsable de eliminar todos sus recursos no administrados; esto se realiza implementando IDisposable. Esta regla comprueba que un tipo T disponible declara un campo F que sea una instancia de un tipo FT disponible. Para cada campo F, la regla intenta buscar una llamada a FT.Dispose. La regla busca los métodos llamados por T.Dispose y en uno nivel más bajo (los métodos llamados por FT.Dispose).

Cómo corregir infracciones

Para corregir una infracción de esta regla, llame a Dispose de los campos que son tipos que implementan IDisposable si es responsable de asignar y liberar los recursos no administrados contenidos en el campo.

Cuándo suprimir advertencias

Es seguro suprimir una advertencia de esta regla si no es responsable de liberar el recurso contenido en el campo o si la llamada a Dispose se produce en un nivel de llamada más profundo que el de las comprobaciones de la regla.

Ejemplo

El ejemplo siguiente muestra un tipo TypeA que implementa IDisposable (FT en la explicación anterior).

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

El ejemplo siguiente muestra un tipo TypeB que infringe esta regla declarando un campo aFieldOfADisposableType (F en la explicación anterior) como un tipo descartable (TypeA) y no llamando a Dispose en el campo. TypeB corresponde a T en la discusión 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);
      }
   }
}

Vea también

Referencia

Implementar Finalize y Dispose para limpiar recursos no administrados

System.IDisposable