CA2216 : Les types pouvant être supprimés doivent déclarer un finaliseur

Article
03/04/2013

TypeName	DisposableTypesShouldDeclareFinalizer
CheckId	CA2216
Catégorie	Microsoft.Usage
Modification avec rupture	Modification sans rupture

Cause

Un type qui implémente System.IDisposable et présente des champs qui laissent entendre l'utilisation de ressources non managées, n'implémente pas de finaliseur conforme à la description de Object.Finalize.

Description de la règle

Une violation de cette règle est rapportée si le type supprimable contient des champs des types suivants :

Comment corriger les violations

Pour corriger une violation de cette règle, implémentez un finaliseur qui appelle votre méthode Dispose.

Quand supprimer les avertissements

ll est possible de supprimer sans risque un avertissement de cette règle si le type n'implémente pas IDisposable en vue de libérer des ressources non managées.

Exemple

L'exemple suivant affiche un type qui ne respecte pas cette règle.

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