¿Cómo se maneja la finalización determinística en C#?

Question

Tengo un objeto C# con un recurso crítico que necesita enjuagarse puntos muy específicos en el tiempo, lo que hace que sea un mal candidato para dejarlo todo para que el recolector de basura lo cuide cada vez que lo hace, ¿cómo debo manejar esto? ¿Hay algo así como el operador de eliminación de C++ que me permita matar manualmente la instancia de este objeto cuando sea necesario?

Answer 1

Esto es precisamente para lo que es la interfaz IDiposable. Liberas los recursos críticos en el método Dispose() y luego dejas el objeto para que el triturador de basura se encargue de la desasignación de la memoria.

Answer 2

Google para la interfaz IDisposable. Este es el único mecanismo disponible para ti. Está hecho a medida si tu recurso crítico no está administrado. Si se trata de un recurso administrado, ¿podría ser más específico sobre lo que debe "enrojecerse"?

Answer 3

La interfaz IDisposable se agregó para admitir la destrucción determinista en C++/CLI, y puede usarla desde cualquier lenguaje .NET. Es lo que quieres.

Answer 4

Si está hablando de un recurso gestionado específico que cree que "DEBE" liberarse en un momento específico, puede llamar específicamente al método Recolectar recolectores de basura, después de eliminar la referencia del objeto, pero hay consideraciones de rendimiento para pensar en ellos, ya que normalmente el recolector de basura sabe cuándo recoger los artículos. Y, en general, es una mala idea.

Como se menciona anteriormente, el patrón IDisposable es útil para liberar recursos no administrados cuando sea necesario.

NOTA: Voy a repetir, PODRÍA llamar a GC.Collect() pero NO es algo bueno, ¡pero es una respuesta válida para la pregunta!

Answer 5

La interfaz IDisposable existe para la destrucción determinista. Hay un patrón para implementarlo correctamente en MSDN.

En tándem, también debería considerar usar el using statement cuando la vida útil de su objeto no abarca múltiples ámbitos.

Answer 6

Está buscando IDisposable. Aquí hay una clase de ejemplo que implementa esto.

class MyDisposableObject : IDisposable 
{ 
    public MyDisposableObject() 
    { 
    } 

    ~MyDisposableObject() 
    { 
     Dispose(false); 
    } 

    private bool disposed; 
    private void Dispose(bool disposing) 
    { 
     if (!this.disposed) 
     { 
      if (disposing) 
      { 
      // Dispose of your managed resources here. 
      } 

      // Dispose of your unmanaged resources here. 

      this.disposed = true; 
     } 
    } 

    void IDisposable.Dispose() 
    { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 
} 

Para usarlo, se puede hacer algo como esto:

public void DoingMyThing() 
{ 
    using (MyDisposableObject obj = new MyDisposableObject()) 
    { 
     // Use obj here. 
    } 
} 

La palabra clave using se asegura de que el método Dispose() en IDisposable se llama al final de su alcance.