Implementación IDisposable en una clase sellada

Question

No creo que esta pregunta haya sido hecha antes. Estoy un poco confundido sobre la mejor manera de implementar IDisposable en una clase sellada específicamente, una clase sellada que no hereda de una clase base. (Es decir, una "clase sellada pura" que es mi término inventado.)

Quizás algunos de ustedes estén de acuerdo conmigo en que las pautas para implementar IDisposable son muy confusas. Dicho esto, quiero saber que la forma en que pretendo implementar IDisposable es suficiente y segura.

Estoy haciendo un código P/Invoke que asigna un IntPtr a través de Marshal.AllocHGlobal y, naturalmente, quiero deshacerme limpiamente de la memoria no administrada que he creado. Así que estoy pensando en algo como esto

using System.Runtime.InteropServices; 

[StructLayout(LayoutKind.Sequential)] 
public sealed class MemBlock : IDisposable 
{ 
    IntPtr ptr; 
    int length; 

    MemBlock(int size) 
    { 
      ptr = Marshal.AllocHGlobal(size); 
      length = size; 
    } 

    public void Dispose() 
    { 
      if (ptr != IntPtr.Zero) 
      { 
       Marshal.FreeHGlobal(ptr); 
       ptr = IntPtr.Zero; 
       GC.SuppressFinalize(this); 
      } 
    } 

    ~MemBlock() 
    { 
      Dispose(); 
    }  
} 

Estoy asumiendo que ya MemBlock y está completamente cerrado y nunca se deriva de otra clase que la implementación de un virtual protected Dispose(bool disposing) no es necesario.

Además, ¿el finalizador es estrictamente necesario? Todos los pensamientos bienvenidos.

Answer 1

El finalizador es necesario como un mecanismo de reserva para eventualmente liberar recursos no administrados si se olvidó de llamar al Dispose.

No, no debe declarar un método virtual en una clase sealed. No compilaría en absoluto. Además, no se recomienda declarar nuevos miembros protected en las clases sealed.

Answer 2

Una pequeña adición; en el caso general, un patrón común es tener un método Dispose(bool disposing), para saber si está en Dispose (donde hay más cosas disponibles) frente al finalizador (donde no debe tocar realmente ningún otro objeto gestionado conectado) .

Por ejemplo:

public void Dispose() { Dispose(true); } 
~MemBlock() { Dispose(false); } 
void Dispose(bool disposing) { // would be protected virtual if not sealed 
    if(disposing) { // only run this logic when Dispose is called 
     GC.SuppressFinalize(this); 
     // and anything else that touches managed objects 
    } 
    if (ptr != IntPtr.Zero) { 
      Marshal.FreeHGlobal(ptr); 
      ptr = IntPtr.Zero; 
    } 
} 

Answer 3

De Joe Duffy's Weblog:

Para las clases selladas, este patrón tiene por qué no ser seguido, lo que significa que debe simplemente poner en práctica su finalizador y Desechar con los métodos simples (es decir, ~ T() (Finalizar) y Eliminar() en C#). Al elegir la última ruta, su código aún debe cumplir con las pautas siguientes con respecto a la implementación de la finalización de y la lógica de disposición .

Así que sí, deberías ser bueno.

Necesita el finalizador como mencionó Mehrdad. Si desea evitarlo, puede echar un vistazo al SafeHandle. No tengo suficiente experiencia con P/Invoke para sugerir el uso correcto.

Answer 4

No puede declarar métodos virtuales en una clase sellada. También declarar miembros protegidos en una clase sellada le da una advertencia del compilador. Entonces lo has implementado correctamente. Llamar a GC.SuppressFinalize (esto) desde el finalizador no es necesario por razones obvias, pero no puede dañar.

Tener un finalizador es esencial cuando se trata de recursos no administrados, ya que no se liberan automáticamente, tiene que hacerlo en el finalizador y se llama automáticamente después de que el objeto se haya recolectado.