Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

System.IDisposable: propriedade e libertação determinística de recursos

`System.IDisposable` define o contrato de libertação síncrona. Usa `using` para definir quando o recurso é libertado e deixa claro quem é responsável por essa operação.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

// 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 é uma interface .NET com um único método, void Dispose(), sem parâmetros nem valor devolvido. Pode libertar um recurso não gerido, chamar Dispose() num objeto pelo qual é responsável ou devolver um array gerido a um conjunto reutilizável (pool). Não liberta a memória do próprio objeto nem substitui a recolha de lixo (GC).

A instrução using (...) { ... } chama Dispose() à saída do bloco; a declaração using var resource = ...; fá-lo à saída do âmbito em que foi declarada. Depois de obter com êxito um recurso que não seja null, o compilador garante a chamada através de try/finally, mesmo que ocorra um return ou uma exceção no bloco. using não interceta exceções. Para a libertação assíncrona, usa await using com System.IAsyncDisposable.

Cabe ao proprietário libertar o recurso, não ao código que apenas o usa por empréstimo. Aqui, IBufferLease herda de IDisposable. ResourceScope também implementa IDisposable, assume a responsabilidade pelo empréstimo e encaminha-lhe a chamada de Dispose(). BufferLease devolve o array uma única vez ao mesmo pool e rejeita acessos posteriores com ObjectDisposedException. As chamadas seguintes a Dispose() não têm efeito (idempotência); isto não garante segurança no acesso por várias threads.

Rent(1) garante pelo menos um elemento, mas não um array inicializado a zero. Escreve antes de ler e, após a devolução, não uses nenhuma referência que tenhas guardado para o array. clearArray: true limpa o conteúdo do array se o pool o guardar para reutilização; não é uma garantia de eliminação segura.

Exemplos

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

Resultado

42
Lease disposed.

Em C# 12 e .NET 8, o programa apresenta `42` e depois `Lease disposed.`. À saída de `using`, o array é devolvido; a segunda chamada a `scope.Dispose()` não tem efeito. A exceção `ObjectDisposedException` intercetada mostra que o empréstimo rejeita uma leitura posterior, não que o pool tenha reutilizado o array.

Lições relacionadas

  • C# · Lição 31 · Avançado · Versão: 3
  • C# · Lição 32 · Avançado · Versão: 3

Fontes