CKTIS / C#
System.IDisposable : propriété et libération déterministe des ressources
`System.IDisposable` définit le contrat de libération synchrone. Utilisez `using` pour fixer le moment de la libération et précisez à qui elle incombe.
Version : C# 12 and .NET 8; later runtimes may add compatible features
Syntaxe
// Separate syntax fragments, not a complete program.
// .NET API excerpt for reference only; do not redeclare it in consumer code.
namespace System
{
public interface IDisposable
{
void Dispose();
}
}
// In the two alternatives below, Acquire() is a placeholder for resource acquisition.
// Statement: dispose on exit from the block.
using (System.IDisposable resource = Acquire())
{
// Use resource.
}
// Declaration (alternative): dispose on exit from the enclosing scope.
using System.IDisposable resource = Acquire();System.IDisposable est une interface .NET qui déclare une seule méthode, void Dispose(), sans paramètre ni valeur de retour. Elle peut libérer une ressource non managée, appeler Dispose() sur un objet dont elle a la charge ou rendre un tableau managé à un pool. Elle ne libère pas la mémoire de l’objet lui-même et ne remplace pas le ramasse-miettes (GC).
L’instruction using (...) { ... } appelle Dispose() à la sortie du bloc ; la déclaration using var resource = ...; le fait à la sortie de sa portée. Une fois une ressource non nulle acquise, le compilateur garantit l’appel au moyen de try/finally, même en cas de return ou d’exception dans le bloc. using n’intercepte pas les exceptions. Pour une libération asynchrone, utilisez await using avec System.IAsyncDisposable.
C’est au propriétaire de libérer la ressource, pas au code qui ne fait que l’emprunter. Ici, IBufferLease hérite de IDisposable. ResourceScope implémente lui-même IDisposable, prend en charge le prêt et lui transmet l’appel à Dispose(). BufferLease rend le tableau une seule fois au même pool et refuse tout accès ultérieur en levant ObjectDisposedException. Les appels suivants à Dispose() sont sans effet (idempotence) ; cela ne garantit pas la sûreté en présence de plusieurs threads.
Rent(1) garantit au moins un élément, mais pas un tableau initialisé à zéro. Écrivez avant de lire et n’utilisez aucune référence conservée vers le tableau après l’avoir rendu. clearArray: true efface le contenu du tableau si le pool le garde pour le réutiliser ; ce n’est pas une garantie d’effacement sécurisé.
Exemples
#nullable enable
using System;
using System.Buffers;
IBufferLease lease = new BufferLease();
IDisposable scope = new ResourceScope(lease);
using (scope)
{
lease.Value = 42;
Console.WriteLine(lease.Value);
}
scope.Dispose();
try
{
_ = lease.Value;
}
catch (ObjectDisposedException)
{
Console.WriteLine("Lease disposed.");
}
interface IBufferLease : IDisposable
{
int Value { get; set; }
}
sealed class BufferLease : IBufferLease
{
private readonly ArrayPool<int> _pool = ArrayPool<int>.Shared;
private int[]? _buffer;
public BufferLease() => _buffer = _pool.Rent(1);
private int[] Buffer =>
_buffer ?? throw new ObjectDisposedException(nameof(BufferLease));
public int Value
{
get => Buffer[0];
set => Buffer[0] = value;
}
public void Dispose()
{
int[]? buffer = _buffer;
if (buffer is null)
return;
_buffer = null;
_pool.Return(buffer, clearArray: true);
}
}
sealed class ResourceScope : IDisposable
{
private IBufferLease? _lease;
public ResourceScope(IBufferLease lease) =>
_lease = lease ?? throw new ArgumentNullException(nameof(lease));
public void Dispose()
{
IBufferLease? lease = _lease;
_lease = null;
lease?.Dispose();
}
}Résultat
42 Lease disposed.
Avec C# 12 et .NET 8, le programme affiche `42`, puis `Lease disposed.`. La sortie du bloc `using` rend le tableau ; le deuxième appel à `scope.Dispose()` est sans effet. L’exception `ObjectDisposedException` interceptée montre que le prêt refuse une lecture ultérieure, pas que le pool a réutilisé le tableau.
Leçons associées
- C# · Leçon 31 · Avancé · Version : 3
- C# · Leçon 32 · Avancé · Version : 3