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

TypeNameTypeName TypesThatOwnNativeResourcesShouldBeDisposableTypesThatOwnNativeResourcesShouldBeDisposable
CheckIdCheckId CA1049CA1049
CategoryCategory Microsoft.DesignMicrosoft.Design
Modification avec ruptureBreaking Change Sans ruptureNon-breaking

CauseCause

Un type référence un System.IntPtr champ, un System.UIntPtr champ, ou un System.Runtime.InteropServices.HandleRef champ, mais n’implémente pas System.IDisposable.A type references a System.IntPtr field, a System.UIntPtr field, or a System.Runtime.InteropServices.HandleRef field, but does not implement System.IDisposable.

Description de la règleRule description

Cette règle suppose que IntPtr, UIntPtr, et HandleRef champs stockent les pointeurs vers les ressources non managées.This rule assumes that IntPtr, UIntPtr, and HandleRef fields store pointers to unmanaged resources. Les types qui allouent des ressources non managées doivent implémenter IDisposable pour permettre aux appelants de libérer ces ressources à la demande et de raccourcir les durées de vie des objets qui contiennent les ressources.Types that allocate unmanaged resources should implement IDisposable to let callers to release those resources on demand and shorten the lifetimes of the objects that hold the resources.

Le modèle de conception recommandée pour nettoyer les ressources non managées consiste à fournir à la fois implicite et un moyen explicite pour libérer ces ressources à l’aide de la System.Object.Finalize (méthode) et le System.IDisposable.Dispose (méthode), respectivement.The recommended design pattern to clean up unmanaged resources is to provide both an implicit and an explicit means to free those resources by using the System.Object.Finalize method and the System.IDisposable.Dispose method, respectively. Le garbage collector appelle la Finalize méthode d’un objet à un moment indéterminé lorsque l’objet est déterminé comme n’étant plus accessible.The garbage collector calls the Finalize method of an object at some indeterminate time after the object is determined to be no longer reachable. Après avoir Finalize est appelée, une autre opération garbage collection est nécessaire pour libérer l’objet.After Finalize is called, an additional garbage collection is required to free the object. Le Dispose méthode permet à l’appelant de libérer explicitement des ressources à la demande, plus tôt que les ressources seraient être libérées si laissé le garbage collector.The Dispose method allows the caller to explicitly release resources on demand, earlier than the resources would be released if left to the garbage collector. Une fois qu’il nettoie les ressources non managées, Dispose doit appeler le System.GC.SuppressFinalize méthode pour informer le garbage collector qui Finalize n’a plus à être appelée ; cela élimine la nécessité pour l’opération garbage collection supplémentaire et raccourcit le durée de vie de l’objet.After it cleans up the unmanaged resources, Dispose should call the System.GC.SuppressFinalize method to let the garbage collector know that Finalize no longer has to be called; this eliminates the need for the additional garbage collection and shortens the lifetime of the object.

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, implémentez IDisposable.To fix a violation of this rule, implement IDisposable.

Quand supprimer les avertissementsWhen to suppress warnings

Il est possible de supprimer un avertissement de cette règle si le type ne fait pas référence à une ressource non managée.It is safe to suppress a warning from this rule if the type does not reference an unmanaged resource. Sinon, ne supprimez aucun avertissement de cette règle, car tout échec d’implémentation IDisposable peut entraîner l’indisponibilité ou la sous-utilisation de ressources non managées.Otherwise, do not suppress a warning from this rule because failure to implement IDisposable can cause unmanaged resources to become unavailable or underused.

ExempleExample

L’exemple suivant illustre un type qui implémente IDisposable pour nettoyer une ressource non managée.The following example shows a type that implements IDisposable to clean up an unmanaged resource.

using System;

namespace DesignLibrary
{
    public class UnmanagedResources : IDisposable
    {
        IntPtr unmanagedResource;
        bool disposed = false;

        public UnmanagedResources() 
        {
            // Allocate the unmanaged resource ...
        }

        public void Dispose() 
        {
            Dispose(true);
            GC.SuppressFinalize(this); 
        }

        protected virtual void Dispose(bool disposing)
        {
            if(!disposed)
            {
                if(disposing)
                {
                    // Release managed resources.
                }

                // Free the unmanaged resource ...

                unmanagedResource = IntPtr.Zero;

                disposed = true;
            }
        }

        ~UnmanagedResources()
        {
            Dispose(false);
        }
    }
}
Imports System

Namespace DesignLibrary

    Public Class UnmanagedResources
        Implements IDisposable

       Dim unmanagedResource As IntPtr
       Dim disposed As Boolean = False

       Sub New 
           ' Allocate the unmanaged resource ...
       End Sub

       Overloads Sub Dispose() Implements IDisposable.Dispose
           Dispose(True)
           GC.SuppressFinalize(Me)
       End Sub

       Protected Overloads Overridable Sub Dispose(disposing As Boolean)
           If Not(disposed) Then

               If(disposing) Then
                   ' Release managed resources.
               End If

               ' Free the unmanaged resource ...

               unmanagedResource = IntPtr.Zero

               disposed = True

           End If
       End Sub

       Protected Overrides Sub Finalize()
           Dispose(False)
       End Sub

    End Class

End Namespace

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

CA2216 : Les types supprimables doivent déclarer un finaliseurCA2216: Disposable types should declare finalizer

CA1001 : Les types qui ont des champs supprimables doivent être supprimablesCA1001: Types that own disposable fields should be disposable

Voir aussiSee also