CA2216 : Les types pouvant être supprimés doivent déclarer un finaliseurCA2216: Disposable types should declare finalizer

• 11/04/2016
• 2 minutes de lecture
• Contributeurs
  • 
  • 
  • 
  • 

CauseCause

Un type qui implémente System.IDisposableet présente des champs qui laissent entendre l’utilisation des ressources non managées, n’implémente pas de finaliseur comme décrit par System.Object.Finalize.A type that implements System.IDisposable, and has fields that suggest the use of unmanaged resources, does not implement a finalizer as described by System.Object.Finalize.

Description de la règleRule Description

Une violation de cette règle est signalée si le type supprimable contient des champs des types suivants :A violation of this rule is reported if the disposable type contains fields of the following types:

• System.IntPtr

• System.UIntPtr

• System.Runtime.InteropServices.HandleRef

Comment corriger les violationsHow to Fix Violations

Pour corriger une violation de cette règle, implémentez un finaliseur qui appelle votre Dispose (méthode).To fix a violation of this rule, implement a finalizer that calls your Dispose method.

Quand supprimer les avertissementsWhen to Suppress Warnings

Il est possible de supprimer un avertissement de cette règle si le type n’implémente pas IDisposable en vue de libérer des ressources non managées.It is safe to suppress a warning from this rule if the type does not implement IDisposable for the purpose of releasing unmanaged resources.

ExempleExample

L’exemple suivant montre un type qui viole cette règle.The following example shows a type that violates this rule.

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

Règles associéesRelated Rules

CA2115 : Appelez GC.KeepAlive lorsque vous utilisez des ressources nativesCA2115: Call GC.KeepAlive when using native resources

CA1816 : Appelez GC.SuppressFinalize correctementCA1816: Call GC.SuppressFinalize correctly

CA1049 : Les types qui ont des ressources natives doivent être supprimablesCA1049: Types that own native resources should be disposable

Voir aussiSee Also

System.IDisposable
System.IntPtr
System.Runtime.InteropServices.HandleRef
System.UIntPtr
System.Object.Finalize
Dispose, modèleDispose Pattern