Implementar un método Dispose
Actualización: noviembre 2007
El modelo para desechar un objeto, lo que se conoce como modelo de Dispose, sirve para imponer orden sobre la duración de un objeto.
El método Dispose de un tipo debe liberar todos los recursos de su propiedad. También debe liberar todos los recursos que posean sus tipos base; para ello, llama al método Dispose de su tipo primario. El método Dispose del tipo primario debe liberar todos los recursos que posee y, a su vez, llamar al método Dispose de su tipo primario, de modo que este patrón se propaga por la jerarquía de tipos base. Para asegurarse de que los recursos se limpien siempre correctamente, un método Dispose debe debe ser invocable varias veces sin que se produzca una excepción.
No supone ninguna ventaja sobre el rendimiento implementar el método Dispose en tipos que utilizan sólo recursos administrados (como matrices) porque el recolector de elementos no utilizados los reclama automáticamente. Utilice principalmente el método Dispose en los objetos administrados que utilizan los recursos nativos y en los objetos COM que se exponen a .NET Framework. Los objetos administrados que utilizan recursos nativos (como la clase FileStream) implementan la interfaz IDisposable.
.gif "Nota importante") Nota importante: |
|---|
Los programadores de C++ no deben utilizar este tema. En su lugar, vea Destructors and Finalizers in Visual C++. En .NET Framework versión 2.0, el compilador de C++ proporciona compatibilidad para implementar la eliminación determinística de los recursos y no permite la implementación directa del método Dispose. |
Un método Dispose debería llamar al método SuppressFinalize en el objeto que está desechando. Si el objeto se encuentra en la cola de finalización en ese momento, SuppressFinalize evita que se llame a su método Finalize. Recuerde que ejecutar un método Finalize afecta al rendimiento. Si el método Dispose ya ha limpiado el objeto, no es necesario que el recolector de elementos no utilizados llame al método Finalize del objeto.
El ejemplo de código proporcionado para el método GC.KeepAlive muestra cómo la recolección de elementos no utilizados rigurosa puede hacer que se ejecute un finalizador mientras un miembro del objeto reclamado todavía se está ejecutando. Suele ser recomendable llamar al método KeepAlive al final de un método Dispose prolongado.
Ejemplo
En el ejemplo de código siguiente se muestra el modelo de diseño recomendado para implementar un método Dispose para las clases que encapsulan recursos no administrados.
Las clases de recursos se derivan normalmente de clases nativas complejas o de las API y se deben personalizar de manera conveniente. Utilice este patrón de código como punto de partida para la creación de una clase de recursos y proporcione la personalización necesaria de acuerdo con los recursos que se encapsulan.
Imports System
Imports System.IO
Class Program
Public Shared Sub Main()
Try
' Initialize a Stream resource to pass
' to the DisposableResource class.
Console.Write("Enter filename and its path: ")
Dim fileSpec As String = Console.ReadLine
Dim fs As FileStream = File.OpenRead(fileSpec)
Dim TestObj As DisposableResource = New DisposableResource(fs)
' Use the resource.
TestObj.DoSomethingWithResource()
' Dispose theresource.
TestObj.Dispose()
Catch e As FileNotFoundException
Console.WriteLine(e.Message)
End Try
End Sub
End Class
' This class shows how to use a disposable resource.
' The resource is first initialized and passed to
' the constructor, but it could also be
' initialized in the constructor.
' The lifetime of the resource does not
' exceed the lifetime of this instance.
' This type does not need a finalizer because it does not
' directly create a native resource like a file handle
' or memory in the unmanaged heap.
Public Class DisposableResource
Implements IDisposable
Private _resource As Stream
Private _disposed As Boolean
' The stream passed to the constructor
' must be readable and not null.
Public Sub New(ByVal stream As Stream)
MyBase.New()
If (stream Is Nothing) Then
Throw New ArgumentNullException("Stream is null.")
End If
If Not stream.CanRead Then
Throw New ArgumentException("Stream must be readable.")
End If
_resource = stream
Dim objTypeName As String = _resource.GetType.ToString
_disposed = False
End Sub
' Demonstrates using the resource.
' It must not be already disposed.
Public Sub DoSomethingWithResource()
If _disposed Then
Throw New ObjectDisposedException("Resource was disposed.")
End If
' Show the number of bytes.
Dim numBytes As Integer = CType(_resource.Length, Integer)
Console.WriteLine("Number of bytes: {0}", numBytes.ToString)
End Sub
Public Overloads Sub Dispose() Implements IDisposable.Dispose
Dispose(True)
' Use SupressFinalize in case a subclass
' of this type implements a finalizer.
GC.SuppressFinalize(Me)
End Sub
Protected Overridable Overloads Sub Dispose(ByVal disposing As Boolean)
If Not _disposed Then
' If you need thread safety, use a lock around these
' operations, as well as in your methods that use the resource.
If disposing Then
If (Not (_resource) Is Nothing) Then
_resource.Dispose()
End If
Console.WriteLine("Object disposed.")
End If
' Indicates that the instance has been disposed.
_resource = Nothing
_disposed = True
End If
End Sub
End Class
using System;
using System.IO;
class Program
{
static void Main()
{
try
{
// Initialize a Stream resource to pass
// to the DisposableResource class.
Console.Write("Enter filename and its path: ");
string fileSpec = Console.ReadLine();
FileStream fs = File.OpenRead(fileSpec);
DisposableResource TestObj = new DisposableResource(fs);
// Use the resource.
TestObj.DoSomethingWithResource();
// Dispose the resource.
TestObj.Dispose();
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
}
}
// This class shows how to use a disposable resource.
// The resource is first initialized and passed to
// the constructor, but it could also be
// initialized in the constructor.
// The lifetime of the resource does not
// exceed the lifetime of this instance.
// This type does not need a finalizer because it does not
// directly create a native resource like a file handle
// or memory in the unmanaged heap.
public class DisposableResource : IDisposable
{
private Stream _resource;
private bool _disposed;
// The stream passed to the constructor
// must be readable and not null.
public DisposableResource(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("Stream in null.");
if (!stream.CanRead)
throw new ArgumentException("Stream must be readable.");
_resource = stream;
_disposed = false;
}
// Demonstrates using the resource.
// It must not be already disposed.
public void DoSomethingWithResource() {
if (_disposed)
throw new ObjectDisposedException("Resource was disposed.");
// Show the number of bytes.
int numBytes = (int) _resource.Length;
Console.WriteLine("Number of bytes: {0}", numBytes.ToString());
}
public void Dispose()
{
Dispose(true);
// Use SupressFinalize in case a subclass
// of this type implements a finalizer.
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
// If you need thread safety, use a lock around these
// operations, as well as in your methods that use the resource.
if (!_disposed)
{
if (disposing) {
if (_resource != null)
_resource.Dispose();
Console.WriteLine("Object disposed.");
}
// Indicate that the instance has been disposed.
_resource = null;
_disposed = true;
}
}
}
Vea también
Conceptos
Referencia
Destructors and Finalizers in Visual C++
Implementar Finalize y Dispose para limpiar recursos no administrados