CKTIS / C#
System.IDisposable: Ressourcenbesitz und deterministische Freigabe
`System.IDisposable` definiert den Vertrag für die synchrone Ressourcenfreigabe. Mit `using` legst du den Zeitpunkt fest; die Besitzverhältnisse bestimmen, wer dafür zuständig ist.
Version: C# 12 and .NET 8; later runtimes may add compatible features
Syntax
// 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 ist eine .NET-Schnittstelle mit genau einer Methode: void Dispose(), ohne Parameter und ohne Rückgabewert. Sie kann eine nicht verwaltete Ressource freigeben, Dispose() für ein eigenes Objekt aufrufen oder ein verwaltetes Array an einen Pool zurückgeben. Sie gibt nicht den Speicher des Objekts selbst frei und ersetzt nicht die Garbage Collection (GC).
Die Anweisung using (...) { ... } ruft Dispose() beim Verlassen des Blocks auf; die Deklaration using var resource = ...; beim Verlassen ihres Gültigkeitsbereichs. Nach erfolgreichem Erwerb einer Ressource, die nicht null ist, stellt der Compiler den Aufruf über try/finally sicher, auch bei return oder einer Ausnahme im Block. using fängt keine Ausnahmen ab. Für die asynchrone Freigabe verwendest du await using mit System.IAsyncDisposable.
Für die Freigabe ist der Besitzer verantwortlich, nicht der Code, der eine Ressource nur ausleiht. Hier erbt IBufferLease von IDisposable. ResourceScope implementiert IDisposable selbst, übernimmt die Verantwortung für die Ausleihe und leitet den Dispose()-Aufruf weiter. BufferLease gibt das Array genau einmal an denselben Pool zurück und weist spätere Zugriffe mit ObjectDisposedException ab. Weitere Dispose()-Aufrufe haben keine Wirkung (Idempotenz); das bedeutet nicht, dass die Implementierung threadsicher ist.
Rent(1) garantiert mindestens ein Element, aber kein mit Nullen initialisiertes Array. Schreibe vor dem Lesen einen Wert und verwende nach der Rückgabe keine aufbewahrte Referenz auf das Array. clearArray: true leert das Array, wenn der Pool es zur Wiederverwendung behält; sicheres Löschen ist damit nicht garantiert.
Beispiele
#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();
}
}Ergebnis
42 Lease disposed.
Unter C# 12 und .NET 8 gibt das Programm zuerst `42` und dann `Lease disposed.` aus. Beim Verlassen von `using` wird das Array zurückgegeben; der zweite Aufruf von `scope.Dispose()` bleibt ohne Wirkung. Die abgefangene `ObjectDisposedException` zeigt, dass die Ausleihe einen späteren Lesezugriff abweist, nicht dass der Pool das Array erneut verwendet hat.
Zugehörige Lektionen
- C# · Lektion 31 · Fortgeschritten · Version: 3
- C# · Lektion 32 · Fortgeschritten · Version: 3