Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

System.IDisposable: proprietà e rilascio deterministico delle risorse

`System.IDisposable` definisce il contratto di rilascio sincrono. Usa `using` per stabilire quando rilasciare la risorsa e chiarisci a chi spetta farlo.

Versione: C# 12 and .NET 8; later runtimes may add compatible features

Sintassi

// 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 è un’interfaccia .NET con un solo metodo, void Dispose(), senza parametri né valore restituito. Può rilasciare una risorsa non gestita, chiamare Dispose() su un oggetto di cui ha la responsabilità o restituire un array gestito a un pool. Non libera la memoria dell’oggetto stesso e non sostituisce la garbage collection (GC).

L’istruzione using (...) { ... } chiama Dispose() quando si esce dal blocco; la dichiarazione using var resource = ...; lo chiama quando si esce dall’ambito in cui è dichiarata. Dopo l’acquisizione riuscita di una risorsa non nulla, il compilatore garantisce la chiamata tramite try/finally, anche in caso di return o di eccezione nel blocco. using non intercetta le eccezioni. Per il rilascio asincrono, usa await using con System.IAsyncDisposable.

Il rilascio spetta al proprietario, non al codice che prende in prestito la risorsa. Qui IBufferLease eredita da IDisposable. ResourceScope implementa a sua volta IDisposable, assume la responsabilità del prestito e gli inoltra la chiamata a Dispose(). BufferLease restituisce l’array una sola volta allo stesso pool e rifiuta gli accessi successivi con ObjectDisposedException. Ripetere Dispose() non ha effetto (idempotenza); ciò non implica che l’implementazione sia thread-safe.

Rent(1) garantisce almeno un elemento, non un array inizializzato a zero. Scrivi prima di leggere e, dopo la restituzione, non usare eventuali riferimenti conservati all’array. clearArray: true azzera il contenuto dell’array se il pool lo conserva per riutilizzarlo; non garantisce una cancellazione sicura.

Esempi

#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();
    }
}

Risultato

42
Lease disposed.

Con C# 12 e .NET 8, il programma stampa `42` e poi `Lease disposed.`. All’uscita da `using` l’array viene restituito; la seconda chiamata a `scope.Dispose()` non ha effetto. L’eccezione `ObjectDisposedException` intercettata mostra che il prestito rifiuta una lettura successiva, non che il pool abbia riutilizzato l’array.

Lezioni correlate

  • C# · Lezione 31 · Avanzato · Versione: 3
  • C# · Lezione 32 · Avanzato · Versione: 3

Fonti