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

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, deve chamar o método Dispose do tipo base de dentro do seu método Dispose. 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 desta regra se a chamada para base.Dispose ocorrer num 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);
            }
        }
    }
}

Consulte também

• System.IDisposable
• Padrão de descarte