CA2215 : Les méthodes Dispose doivent appeler la méthode Dispose de la classe de base

Cause

Un type qui implémente System.IDisposable hérite d’un type qui implémente également IDisposable. La méthode Dispose du type hérité n’appelle pas la méthode Dispose du type parent.

Description de la règle

Si un type hérite d’un type supprimable, il doit appeler la méthode Dispose du type de base à partir de sa propre méthode Dispose. L’appel de la méthode Dispose du type de base garantit que toutes les ressources créées par le type de base sont libérées.

Comment corriger les violations

Pour corriger une violation de cette règle, appelez base.Dispose dans votre méthode Dispose.

Quand supprimer les avertissements

Vous pouvez sans risque supprimer un avertissement de cette règle si l’appel à base.Dispose se produit à un niveau d’appel plus profond que celui vérifié par la règle.

Supprimer un avertissement

Si vous voulez supprimer une seule violation, ajoutez des directives de préprocesseur à votre fichier source pour désactiver et réactiver la règle.

#pragma warning disable CA2215
// The code that's violating the rule is on this line.
#pragma warning restore CA2215

Pour désactiver la règle sur un fichier, un dossier ou un projet, définissez sa gravité sur none dans le fichier de configuration.

[*.{cs,vb}]
dotnet_diagnostic.CA2215.severity = none

Pour plus d’informations, consultez Comment supprimer les avertissements de l’analyse de code.

Exemple

L’exemple suivant montre deux types, TypeA qui implémente IDisposable, et TypeB qui hérite du type TypeA et appelle correctement sa méthode Dispose.

Namespace ca2215

    Public Class TypeA
        Implements IDisposable

        Protected Overridable Overloads Sub Dispose(disposing As Boolean)
            If disposing Then
                ' dispose managed resources
            End If
            
            ' free native resources
        End Sub

        Public Overloads Sub Dispose() Implements IDisposable.Dispose
            Dispose(True)
            GC.SuppressFinalize(Me)
        End Sub

        ' Disposable types implement a finalizer.
        Protected Overrides Sub Finalize()
            Dispose(False)
            MyBase.Finalize()
        End Sub

    End Class

    Public Class TypeB
        Inherits TypeA

        Protected Overrides Sub Dispose(disposing As Boolean)
            If Not disposing Then
                MyBase.Dispose(False)
            End If
        End Sub

    End Class

End Namespace

using System;

namespace ca2215
{
    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);
        }
    }

    public class TypeB : TypeA
    {
        protected override void Dispose(bool disposing)
        {
            if (!disposing)
            {
                base.Dispose(false);
            }
        }
    }
}

Voir aussi

• System.IDisposable
• Dispose, modèle