CA1063: Implemente IDisposable correctamenteCA1063: Implement IDisposable correctly

TypeNameTypeName ImplementIDisposableCorrectlyImplementIDisposableCorrectly
Identificador de comprobaciónCheckId CA1063CA1063
CategoríaCategory Microsoft.DesignMicrosoft.Design
Cambio problemáticoBreaking Change Poco problemáticoNon-breaking

MotivoCause

IDisposableno se implementa correctamente.IDisposable is not implemented correctly. A continuación se enumeran algunas causas de este problema:Some reasons for this problem are listed here:

  • IDisposable se implementa de nuevo en la clase.IDisposable is re-implemented in the class.

  • Finalizar se vuelve a reemplazar.Finalize is re-overridden.

  • Se reemplaza Dispose.Dispose is overridden.

  • Dispose() no es público, sealed o denominado Dispose.Dispose() is not public, sealed, or named Dispose.

  • Dispose (bool) no está protegido, virtual o no sellado.Dispose(bool) is not protected, virtual, or unsealed.

  • En tipos no sellados, Dispose() debe llamar a Dispose (true).In unsealed types, Dispose() must call Dispose(true).

  • Para los tipos no sellados, la implementación de finalización no llama a uno o ambos Dispose (bool) o el finalizador de la clase de caso.For unsealed types, the Finalize implementation does not call either or both Dispose(bool) or the case class finalizer.

    Infracción de cualquiera de estos patrones desencadenará esta advertencia.Violation of any one of these patterns will trigger this warning.

    Cada tipo IDisposable de raíz no sellada debe proporcionar su propio método Dispose (bool) void virtual protegido.Every unsealed root IDisposable type must provide its own protected virtual void Dispose(bool) method. Dispose() debe llamar a Dispose (true) y Finalize debe llamar a Dispose (false).Dispose() should call Dipose(true) and Finalize should call Dispose(false). Si va a crear un tipo IDisposable de raíz no sellada, debe definir Dispose (bool) y llamarlo.If you are creating an unsealed root IDisposable type, you must define Dispose(bool) and call it. Para obtener más información, consulte limpiar recursos no administrados en el directrices de diseño de Framework sección de la documentación de .NET Framework.For more information, see Cleaning Up Unmanaged Resources in the Framework Design Guidelines section of the .NET Framework documentation.

Descripción de la reglaRule Description

Todos los tipos IDisposable deben implementar el modelo de Dispose correctamente.All IDisposable types should implement the Dispose pattern correctly.

Cómo corregir infraccionesHow to Fix Violations

Examine el código y determinar cuál de las siguientes resoluciones corregirá esta infracción.Examine your code and determine which of the following resolutions will fix this violation.

  • Quite IDisposable de la lista de interfaces que se implementan en {0} y reemplazar la implementación de Dispose de clase base en su lugar.Remove IDisposable from the list of interfaces that are implemented by {0} and override the base class Dispose implementation instead.

  • Quite el finalizador del tipo {0}, invalide Dispose (colocación de bool) y coloque la lógica de finalización en la ruta de acceso del código donde 'desechar' es false.Remove the finalizer from type {0}, override Dispose(bool disposing), and put the finalization logic in the code path where 'disposing' is false.

  • Quitar {0}, invalide Dispose (colocación de bool) y coloque la lógica de dispose en la ruta de acceso del código donde 'desechar' es true.Remove {0}, override Dispose(bool disposing), and put the dispose logic in the code path where 'disposing' is true.

  • Asegúrese de que {0} se declaró como public y sealed.Ensure that {0} is declared as public and sealed.

  • Cambiar el nombre de {0} a 'Dispose' y asegúrese de que se declara como public y sealed.Rename {0} to 'Dispose' and make sure that it is declared as public and sealed.

  • Asegúrese de que ese {0} se declara como protegido, virtual y no sellado.Make sure that {0} is declared as protected, virtual, and unsealed.

  • Modificar {0} para que llama a Dispose (true), a continuación, llame a GC. SuppressFinalize en la instancia del objeto actual ('this' o 'Me' en Visual BasicVisual Basic) y, a continuación, se devuelve.Modify {0} so that it calls Dispose(true), then calls GC.SuppressFinalize on the current object instance ('this' or 'Me' in Visual BasicVisual Basic), and then returns.

  • Modificar {0} para que se llama a Dispose (false) y, a continuación, se devuelve.Modify {0} so that it calls Dispose(false) and then returns.

  • Si está escribiendo una clase IDisposable de raíz no sellada, asegúrese de que la implementación de IDisposable sigue el patrón descrito anteriormente en esta sección.If you are writing an unsealed root IDisposable class, make sure that the implementation of IDisposable follows the pattern that is described earlier in this section.

Cuándo suprimir advertenciasWhen to Suppress Warnings

No suprima las advertencias de esta regla.Do not suppress a warning from this rule.

Ejemplo de pseudocódigoPseudo-code Example

El pseudocódigo siguiente proporciona un ejemplo general de cómo se debe implementar Dispose (bool) en una clase que utiliza administrada y recursos nativos.The following pseudo-code provides a general example of how Dispose(bool) should be implemented in a class that uses managed and native resources.

public class Resource : IDisposable   
{  
    private IntPtr nativeResource = Marshal.AllocHGlobal(100);  
    private AnotherResource managedResource = new AnotherResource();  

// Dispose() calls Dispose(true)  
    public void Dispose()  
    {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  
    // NOTE: Leave out the finalizer altogether if this class doesn't   
    // own unmanaged resources itself, but leave the other methods  
    // exactly as they are.   
    ~Resource()   
    {  
        // Finalizer calls Dispose(false)  
        Dispose(false);  
    }  
    // The bulk of the clean-up code is implemented in Dispose(bool)  
    protected virtual void Dispose(bool disposing)  
    {  
        if (disposing)   
        {  
            // free managed resources  
            if (managedResource != null)  
            {  
                managedResource.Dispose();  
                managedResource = null;  
            }  
        }  
        // free native resources if there are any.  
        if (nativeResource != IntPtr.Zero)   
        {  
            Marshal.FreeHGlobal(nativeResource);  
            nativeResource = IntPtr.Zero;  
        }  
    }  
}