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

Artigo
09/06/2023

Propriedade	valor
ID da regra	CA2215
Cargo	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 8	Não

Causa

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 base garante que todos os recursos criados pelo tipo Dispose base sejam liberados.

Como corrigir violações

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

Quando suprimir avisos

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

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 para um arquivo, pasta ou projeto, defina sua severidade 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, que implementa , TypeA e que herda do tipo TypeA e TypeB chama corretamente seu Dispose IDisposablemé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