CKTIS / C#
System.IDisposable: propiedad y liberación determinista de recursos
`System.IDisposable` define el contrato de liberación síncrona. Usa `using` para decidir cuándo liberar el recurso y deja claro quién debe hacerlo.
Versión: C# 12 and .NET 8; later runtimes may add compatible features
Sintaxis
// 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 es una interfaz de .NET con un único método, void Dispose(), sin parámetros ni valor de retorno. Puede liberar un recurso no administrado, llamar a Dispose() en un objeto propio o devolver una matriz administrada a un grupo de reutilización. No libera la memoria del propio objeto ni sustituye al recolector de elementos no utilizados (GC).
La instrucción using (...) { ... } llama a Dispose() al salir del bloque; la declaración using var resource = ...; lo hace al salir de su ámbito. Tras adquirir correctamente un recurso que no sea null, el compilador garantiza la llamada mediante try/finally, incluso si se ejecuta un return o se produce una excepción dentro del bloque. using no captura excepciones. Para la liberación asíncrona, usa await using con System.IAsyncDisposable.
El propietario debe liberar el recurso, no el código que solo lo toma prestado. En el ejemplo, IBufferLease hereda de IDisposable. ResourceScope también implementa IDisposable, asume la responsabilidad sobre el préstamo y le delega la llamada a Dispose(). BufferLease devuelve la matriz una sola vez al mismo grupo y rechaza el acceso posterior con ObjectDisposedException. Las llamadas repetidas a Dispose() no tienen efecto (idempotencia); eso no implica seguridad para subprocesos.
Rent(1) garantiza al menos un elemento, no una matriz inicializada a cero. Escribe antes de leer y, tras devolver la matriz, no uses ninguna referencia conservada a ella. clearArray: true borra el contenido de la matriz si el grupo la conserva para reutilizarla; no garantiza el borrado seguro.
Ejemplos
#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.
Con C# 12 y .NET 8, el programa muestra `42` y después `Lease disposed.`. Al salir de `using` se devuelve la matriz; la segunda llamada a `scope.Dispose()` no hace nada. La excepción `ObjectDisposedException` capturada demuestra que el préstamo rechaza una lectura posterior, no que el grupo haya reutilizado la matriz.
Lecciones relacionadas
- C# · Lección 31 · Avanzado · Versión: 3
- C# · Lección 32 · Avanzado · Versión: 3