CA1063 : Implémenter IDisposable correctementCA1063: Implement IDisposable correctly

TypeNameTypeName ImplementIDisposableCorrectlyImplementIDisposableCorrectly
CheckIdCheckId CA1063CA1063
CategoryCategory Microsoft.DesignMicrosoft.Design
Modification avec ruptureBreaking Change Sans ruptureNon-breaking

CauseCause

Le System.IDisposable interface n’est pas implémentée correctement.The System.IDisposable interface is not implemented correctly. Raisons possibles sont les suivantes :Possible reasons for this include:

  • IDisposable est réimplémentée dans la classe.IDisposable is reimplemented in the class.

  • Finaliser est reoverridden.Finalize is reoverridden.

  • Dispose() est remplacée.Dispose() is overridden.

  • La méthode Dispose() n’est pas publique, sealed, ou nommé Dispose.The Dispose() method is not public, sealed, or named Dispose.

  • Dispose (bool) n’est pas protégé, virtuel ou non scellé.Dispose(bool) is not protected, virtual, or unsealed.

  • Dans les types non scellés, Dispose() doit appeler Dispose (true).In unsealed types, Dispose() must call Dispose(true).

  • Pour les types unsealed, l’implémentation Finalize n’appelle pas un ou les deux dispose (bool) ou le finaliseur de la classe de base.For unsealed types, the Finalize implementation does not call either or both Dispose(bool) or the base class finalizer.

Violation de l’un de ces modèles déclenche l’avertissement CA1063.Violation of any one of these patterns triggers warning CA1063.

Chaque type unsealed qui déclare et implémente la IDisposable interface doit fournir sa propre méthode Dispose (bool) void virtuelle protégée.Every unsealed type that declares and implements the IDisposable interface must provide its own protected virtual void Dispose(bool) method. Dispose() doit appeler Dipose (true), et le finaliseur doit appeler la méthode Dispose (false).Dispose() should call Dipose(true), and the finalizer should call Dispose(false). Si vous créez un type unsealed qui déclare et implémente la IDisposable interface, vous devez définir dispose (bool) et l’appeler.If you create an unsealed type that declares and implements the IDisposable interface, you must define Dispose(bool) and call it. Pour plus d’informations, consultez nettoyer les ressources non managées (guide .NET) et modèle Dispose.For more information, see Clean up unmanaged resources (.NET guide) and Dispose pattern.

Description de la règleRule description

Tous les IDisposable types doivent implémenter le modèle Dispose correctement.All IDisposable types should implement the Dispose pattern correctly.

Comment corriger les violationsHow to fix violations

Examinez votre code et déterminer lequel des solutions suivantes corrigera cette violation :Examine your code and determine which of the following resolutions will fix this violation:

  • Supprimer IDisposable dans la liste des interfaces qui sont implémentées par votre type et substituez l’implémentation de Dispose de la classe de base à la place.Remove IDisposable from the list of interfaces that are implemented by your type, and override the base class Dispose implementation instead.

  • Supprimer le finaliseur de votre type, substituez Dispose (bool disposing) et placez la logique de finalisation dans le chemin d’accès du code où 'disposing' a la valeur false.Remove the finalizer from your type, override Dispose(bool disposing), and put the finalization logic in the code path where 'disposing' is false.

  • Substituez Dispose (bool disposing) et placez la logique dispose dans le chemin d’accès du code où 'disposing' a la valeur true.Override Dispose(bool disposing), and put the dispose logic in the code path where 'disposing' is true.

  • Assurez-vous que Dispose() est déclaré comme public et sealed.Make sure that Dispose() is declared as public and sealed.

  • Renommer votre méthode dispose pour Dispose et assurez-vous qu’il est déclaré comme public et sealed.Rename your dispose method to Dispose and make sure that it's declared as public and sealed.

  • Vérifiez que dispose (bool) est déclaré comme protected, virtuel et non scellé.Make sure that Dispose(bool) is declared as protected, virtual, and unsealed.

  • Modifier Dispose() afin qu’il appelle Dispose (true), puis appelle SuppressFinalize sur l’instance d’objet actuelle (this, ou Me en Visual Basic), puis retourne.Modify Dispose() so that it calls Dispose(true), then calls SuppressFinalize on the current object instance (this, or Me in Visual Basic), and then returns.

  • Modifiez votre finaliseur afin qu’il appelle Dispose (false), puis retourne.Modify your finalizer so that it calls Dispose(false) and then returns.

  • Si vous créez un type unsealed qui déclare et implémente la IDisposable l’interface, assurez-vous que l’implémentation de IDisposable suit le modèle qui est décrite plus haut dans cette section.If you create an unsealed type that declares and implements the IDisposable interface, make sure that the implementation of IDisposable follows the pattern that is described earlier in this section.

Quand supprimer les avertissementsWhen to suppress warnings

Ne supprimez aucun avertissement de cette règle.Do not suppress a warning from this rule.

Exemple de pseudo-codePseudo-code example

Le pseudo-code suivant fournit un exemple général de la manière dont dispose (bool) doit être implémentée dans une classe qui utilise managée et les ressources natives.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, 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;
        }
    }
}

Voir aussiSee also