traduccion - ¿Cómo se maneja la finalización determinista en C#?

invocar garbage collector c#

Question

Tengo un objeto C # con un recurso crítico que necesita ser enjuagado 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 maneja, ¿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

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 2

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

En conjunto, también debería considerar usar la instrucción using cuando la duración de su objeto no abarca múltiples ámbitos.

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 Recolector de Recolectores de Basura, después de eliminar la referencia del objeto, pero hay consideraciones de rendimiento que debe tener en cuenta, como normalmente el recolector de basura sabe cuándo recoger los artículos. Y, en general, es una mala idea.

Como otros mencionan arriba, el patrón IDisposable es útil para liberar recursos no administrados cuando sea necesario.

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

Answer 5

Usted 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, puedes 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 llame al final de su alcance.

Answer 6

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.