Nettoyage des ressources en

À propos de Nettoyage des ressources

L'interface IDisposable est au cœur du nettoyage des ressources et joue deux rôles importants en C# :

• Elle indique aux utilisateurs de la classe qui l'implémente qu'il leur incombe de faire savoir à cette classe (en appelant la méthode Dispose()) qu'elle n'est plus nécessaire, afin qu'elle puisse libérer les ressources non managées qu'elle détient ou réinitialiser son état interne selon le cas. Cela contraste avec l'approche habituelle du nettoyage, qui consiste à laisser le garbage collector tout nettoyer (principalement libérer la mémoire).
• Conjointement avec le compilateur et le runtime, l'interface IDisposable prend en charge l'instruction using abordée dans l'exercice resource-lifetime.

Il est possible, mais peu probable, que Dispose() soit appelé via l'interface dans une sorte de routine de nettoyage générique.

On rencontre le plus souvent IDisposable avec des classes de bibliothèque qui encapsulent des ressources du système d'exploitation (non managées), telles que System.IO.Stream et System.IO.TextReader. (Les Stream et les TextReader sont traités dans d'autres exercices.)

public class TextHandler : IDispoable
{
    private TextReader reader = new TextReader(...);

    public void Dispose()
    {
        reader.Dispose();
    }
}

Si une classe que tu utilises implémente l'interface IDispoable, tu dois t'assurer que Dispose() est appelé (à l'aide de clauses catch et finally) lorsque l'instance n'est plus nécessaire. Si une classe possède un membre qui implémente IDisposable, elle devra sans doute implémenter IDisposable elle-même, afin que Dispose() puisse être appelé pour libérer le membre qui implémente IDisposble.

public class Activity : IDisposable
{
    private MyResource myResource;

    public Activity()
    {
        myResource = new MyResource();
    }

    public void Perform()
    {
        try
        {
            myResource.BeUseful();
        }
        catch (Exception)
        {
            myResource.Dispose();
        }
    }

    public void Dispose()
    {
        myResource.Dispose();
    }
}

L'interface IDisposable peut être utile même lorsqu'aucune ressource non managée n'entre en jeu. Imaginons un objet à longue durée de vie qui attend d'objets à courte durée de vie qu'ils s'enregistrent auprès de lui, puis se désenregistrent lorsqu'ils ne sont plus nécessaires. Implémenter IDisposable sur l'objet à courte durée de vie avertit le développeur qui utilise cette classe que Dispose() doit être appelé à la fin de la vie de cet objet.

Modèle Dispose

Tu verras des références au modèle Dispose dans la documentation. Le modèle Dispose inclut l'appel à Dispose() depuis le finaliseur d'une classe et garantit que la libération des ressources des classes de base est gérée correctement. Le modèle Dispose est traité dans un exercice ultérieur.

Le modèle Dispose concerne principalement les ressources non managées. Si tu utilises le mécanisme P/Invoke et des méthodes extern, tu dois comprendre comment et quand implémenter le modèle Dispose. La plupart des développeurs C# ont rarement affaire directement à des ressources non managées de cette façon.