CA2215: Os métodos de descarte devem chamar a classe base dispose

Artigo
11/12/2024

Property	valor
ID da regra	CA2215
Título	Os métodos de descarte devem chamar a classe base dispose
Categoria	Utilização
A correção está quebrando ou não quebrando	Sem quebra
Habilitado por padrão no .NET 9	Não

Motivo

Um tipo que implementa System.IDisposable herda de um tipo que também implementa IDisposable. O Dispose método do tipo de herança não chama o Dispose método do tipo pai.

Descrição da regra

Se um tipo herda de um tipo descartável, ele deve chamar o Dispose método do tipo base de dentro de seu próprio Dispose método. Chamar o método de tipo Dispose base garante que todos os recursos criados pelo tipo base sejam liberados.

Como corrigir violações

Para corrigir uma violação desta regra, chame base.Dispose no seu Dispose método.

Quando suprimir avisos

É seguro suprimir um aviso dessa regra se a chamada para base.Dispose ocorrer em um nível de chamada mais profundo do que a regra verifica.

Suprimir um aviso

Se você quiser apenas suprimir uma única violação, adicione diretivas de pré-processador ao seu arquivo de origem para desativar e, em seguida, reativar a regra.

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

Para desabilitar a regra de um arquivo, pasta ou projeto, defina sua gravidade como none no arquivo de configuração.

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

Para obter mais informações, consulte Como suprimir avisos de análise de código.

Exemplo

O exemplo a seguir mostra dois tipos, TypeA que implementa IDisposable, e TypeB que herda do tipo TypeA e chama corretamente seu Dispose método.

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

Partilhar via