Verwerfbare Typen sollten einen Finalizer deklarieren

Artikel
08/20/2008

Aktualisiert: November 2007

TypeName	DisposableTypesShouldDeclareFinalizer
CheckId	CA2216
Kategorie	Microsoft.Usage
Unterbrechende Änderung	Nicht unterbrechend

Ursache

Ein Typ, der System.IDisposable implementiert und Felder besitzt, bei denen die Verwendung nicht verwalteter Ressourcen empfohlen wird, implementiert keinen Finalizer wie von Object.Finalize beschrieben.

Regelbeschreibung

Ein Verstoß gegen diese Regel wird gemeldet, wenn der verwerfbare Typ Felder folgender Typen enthält:

Behandlung von Verstößen

Um einen Verstoß gegen diese Regel zu beheben, implementieren Sie einen Finalizer, der die Dispose-Methode aufruft.

Wann sollten Warnungen unterdrückt werden?

Eine Warnung dieser Regel kann gefahrlos unterdrückt werden, wenn der Typ nicht IDisposable implementiert, um nicht verwaltete Ressourcen freizugeben.

Beispiel

Im folgenden Beispiel wird ein Typ veranschaulicht, der gegen diese Regel verstößt.

using System;  
using System.Runtime.InteropServices;

namespace UsageLibrary
{
    public class  DisposeMissingFinalize :IDisposable
    {
        private bool disposed = false;
        private IntPtr unmanagedResource;

        [DllImport("native.dll")]
        private static extern IntPtr AllocateUnmanagedResource();

        [DllImport("native.dll")]
        private static extern void FreeUnmanagedResource(IntPtr p);

        DisposeMissingFinalize()
        {
            unmanagedResource = AllocateUnmanagedResource();
        }

        protected virtual void Dispose(bool disposing) 
        {
            if (!disposed) 
            {
                // Dispose of resources held by this instance.
                FreeUnmanagedResource(unmanagedResource);
                disposed = true;

                // Suppress finalization of this disposed instance.
                if (disposing)
                {
                    GC.SuppressFinalize(this);
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
        }

        // Disposable types with unmanaged resources implement a finalizer.
        // Uncomment the following code to satisfy rule:
        //  DisposableTypesShouldDeclareFinalizer
        // ~TypeA()
        // {
        //     Dispose(false);
        // }
    }
}