CA2215: Los métodos Dispose deben llamar al método Dispose de la clase base

Artículo
11/15/2023

Propiedad	Value
Identificador de la regla	CA2215
Título	Los métodos Dispose deben llamar al método Dispose de la clase base
Categoría	Uso
La corrección es problemática o no problemática	Poco problemático
Habilitado de forma predeterminada en .NET 8	No

Causa

Un tipo que implementa System.IDisposable hereda de un tipo que también implementa IDisposable. El método Dispose del tipo heredado no llama al método Dispose del tipo principal.

Descripción de la regla

Si un tipo se hereda de un tipo descartable, debe llamar al método Dispose del tipo base desde su propio método Dispose. La llamada al método Dispose de tipo base garantiza que se liberen los recursos creados por el tipo base.

Cómo corregir infracciones

Para corregir una infracción de esta regla, llama a base.Disposeen tu método Dispose.

Cuándo suprimir las advertencias

Es seguro suprimir una advertencia de esta regla si la llamada a base.Dispose se produce en un nivel de llamada más profundo que las comprobaciones de regla.

Supresión de una advertencia

Si solo quiere suprimir una única infracción, agregue directivas de preprocesador al archivo de origen para deshabilitar y volver a habilitar la regla.

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

Para deshabilitar la regla de un archivo, una carpeta o un proyecto, establezca su gravedad en none del archivo de configuración.

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

Para obtener más información, consulte Procedimiento para suprimir advertencias de análisis de código.

Ejemplo

En el ejemplo siguiente se muestran dos tipos, TypeA que implementa IDisposable y TypeB que hereda del tipo TypeA y llama correctamente a su 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);
            }
        }
    }
}