CA2215: Kassera metoder ska anropa basklassens bortskaffning

Artikel
11/14/2023

Property	Värde
Regel-ID	CA2215
Title	Kassera metoder bör anropa basklassens bortskaffning
Kategori	Användning
Korrigeringen är icke-bakåtkompatibel	Icke-icke-bryta
Aktiverad som standard i .NET 9	Nej

Orsak

En typ som implementerar System.IDisposable ärver från en typ som även implementerar IDisposable. Metoden Dispose för ärvningstypen anropar inte metoden för den Dispose överordnade typen.

Regelbeskrivning

Om en typ ärver från en engångstyp måste den Dispose anropa metoden för bastypen inifrån sin egen Dispose metod. Genom att anropa bastypsmetoden Dispose ser du till att alla resurser som skapas av bastypen släpps.

Så här åtgärdar du överträdelser

Om du vill åtgärda ett brott mot den här regeln anropar du base.Dispose i din Dispose metod.

När du ska ignorera varningar

Det är säkert att ignorera en varning från den här regeln om anropet till base.Dispose inträffar på en djupare anropsnivå än regeln kontrollerar.

Ignorera en varning

Om du bara vill förhindra en enda överträdelse lägger du till förprocessordirektiv i källfilen för att inaktivera och aktiverar sedan regeln igen.

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

Om du vill inaktivera regeln för en fil, mapp eller ett projekt anger du dess allvarlighetsgrad till none i konfigurationsfilen.

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

Mer information finns i Så här utelämnar du kodanalysvarningar.

Exempel

I följande exempel visas två typer, TypeA som implementerar IDisposable, och TypeB som ärver från typen TypeA och anropar dess Dispose metod korrekt.

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

Dela via