CA2215: I metodi Dispose devono chiamare il metodo Dispose della classe base

Causa

Tipo che implementa System.IDisposable eredita da un tipo che implementa IDisposableanche . Il Dispose metodo del tipo che eredita non chiama il Dispose metodo del tipo padre.

Descrizione regola

Se un tipo eredita da un tipo eliminabile, deve chiamare il Dispose metodo del tipo di base dall'interno del proprio Dispose metodo. La chiamata al metodo del tipo di Dispose base garantisce che tutte le risorse create dal tipo di base vengano rilasciate.

Come correggere le violazioni

Per correggere una violazione di questa regola, chiamare base.Dispose nel Dispose metodo .

Quando eliminare gli avvisi

È possibile eliminare un avviso da questa regola se la chiamata a viene eseguita a un livello di chiamata più profondo rispetto ai baseDispose controlli della regola.

Eliminare un avviso

Se si vuole eliminare una singola violazione, aggiungere direttive del preprocessore al file di origine per disabilitare e quindi riabilitare la regola.

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

Per disabilitare la regola per un file, una cartella o un progetto, impostarne la gravità none su nel file di configurazione.

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

Per altre informazioni, vedere Come eliminare gli avvisi di analisi del codice.

Esempio

Nell'esempio seguente vengono illustrati due tipi, TypeA che implementano IDisposablee TypeB che ereditano dal tipo TypeA e chiamano correttamente il Dispose relativo metodo.

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

Vedi anche

• System.IDisposable
• Criterio Dispose