CA2215: Métodos Dispose devem chamar o descarte da classe base

Artigo
09/06/2023

Property	Valor
ID da regra	CA2215
Título	Métodos Dispose devem chamar o descarte da classe base
Categoria	Usage
Correção interruptiva ou sem interrupção	Sem interrupção
Habilitado por padrão no .NET 8	Não

Causa

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

Descrição da regra

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

Como corrigir violações

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

Quando suprimir avisos

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

Suprimir um aviso

Para suprimir apenas uma violação, adicione diretivas de pré-processador ao arquivo de origem a fim de desabilitar e, em seguida, reabilitar 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 em um arquivo, uma pasta ou um projeto, defina a severidade como none no arquivo de configuração.

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

Para obter mais informações, confira 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 método 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);
            }
        }
    }
}

Share via