Perché chiamare dispose (false) nel distruttore?

Question

Quello che segue è un tipico esempio di modello di smaltimento:

 public bool IsDisposed { get; private set; }

  #region IDisposable Members

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

  protected virtual void Dispose(bool disposing)
  {
    if (!IsDisposed)
    {
      if (disposing)
      {
        //perform cleanup here
      }

      IsDisposed = true;
    }
  }

  ~MyObject()
  {
    Dispose(false);
  }

Capisco cosa fa smaltire, ma quello che non capisco è perché vorresti chiamare dispose (false) nel distruttore? Se guardi la definizione non farebbe assolutamente nulla, quindi perché qualcuno dovrebbe scrivere codice come questo? Non avrebbe senso semplicemente non chiamare dispose dal distruttore?

Answer 1

Il finalizzatore viene utilizzato come fallback se l'oggetto non è stato disposto correttamente per qualche motivo. Normalmente viene chiamato il metodo Dispose () che rimuove il collegamento del finalizzatore e trasforma l'oggetto in un normale oggetto gestito che il garbage collector può rimuovere facilmente.

Ecco un esempio di MSDN di una classe che ha gestito e risorse non gestite per la pulizia.

Si noti che le risorse gestite vengono ripulite solo se smaltimento è vero, ma le risorse non gestite vengono sempre ripulite.

public class MyResource: IDisposable
{
    // Pointer to an external unmanaged resource.
    private IntPtr handle;
    // Other managed resource this class uses.
    private Component component = new Component();
    // Track whether Dispose has been called.
    private bool disposed = false;

    // The class constructor.
    public MyResource(IntPtr handle)
    {
        this.handle = handle;
    }

    // Implement IDisposable.
    // Do not make this method virtual.
    // A derived class should not be able to override this method.
    public void Dispose()
    {
        Dispose(true);
        // This object will be cleaned up by the Dispose method.
        // Therefore, you should call GC.SupressFinalize to
        // take this object off the finalization queue
        // and prevent finalization code for this object
        // from executing a second time.
        GC.SuppressFinalize(this);
    }

    // Dispose(bool disposing) executes in two distinct scenarios.
    // If disposing equals true, the method has been called directly
    // or indirectly by a user's code. Managed and unmanaged resources
    // can be disposed.
    // If disposing equals false, the method has been called by the
    // runtime from inside the finalizer and you should not reference
    // other objects. Only unmanaged resources can be disposed.
    private void Dispose(bool disposing)
    {
        // Check to see if Dispose has already been called.
        if(!this.disposed)
        {
            // If disposing equals true, dispose all managed
            // and unmanaged resources.
            if(disposing)
            {
                // Dispose managed resources.
                component.Dispose();
            }

            // Call the appropriate methods to clean up
            // unmanaged resources here.
            // If disposing is false,
            // only the following code is executed.
            CloseHandle(handle);
            handle = IntPtr.Zero;

            // Note disposing has been done.
            disposed = true;

        }
    }

    // Use interop to call the method necessary
    // to clean up the unmanaged resource.
    [System.Runtime.InteropServices.DllImport("Kernel32")]
    private extern static Boolean CloseHandle(IntPtr handle);

    // Use C# destructor syntax for finalization code.
    // This destructor will run only if the Dispose method
    // does not get called.
    // It gives your base class the opportunity to finalize.
    // Do not provide destructors in types derived from this class.
    ~MyResource()
    {
        // Do not re-create Dispose clean-up code here.
        // Calling Dispose(false) is optimal in terms of
        // readability and maintainability.
        Dispose(false);
    }
}

Answer 2

  

" L'idea qui è quella   Dispose (booleano) sa se lo è   essere chiamato a fare pulizia esplicita   (il booleano è vero) contro l'essere   chiamato a causa di una garbage collection   (il booleano è falso). Questo   la distinzione è utile perché, quando   essendo disposto esplicitamente, il   Il metodo Dispose (Boolean) può tranquillamente   eseguire il codice utilizzando il tipo di riferimento   campi che fanno riferimento ad altri oggetti   sapendo per certo che questi altri   gli oggetti non sono stati finalizzati o   smaltito ancora. Quando il booleano è   false, il metodo Dispose (booleano)   non dovrebbe eseguire codice a cui si fa riferimento   campi del tipo di riferimento perché quelli   gli oggetti potrebbero essere già stati   finalizzato ".

Ci sono molte più informazioni nel “ Linee guida per la progettazione di smaltimento, finalizzazione e gestione delle risorse ".

Modifica: collegamento.

Answer 3

Non ci sono distruttori in C #. Questo è un finalizzatore, che è una cosa diversa.

La distinzione è se è necessario pulire o meno gli oggetti gestiti. Non vuoi provare a ripulirli nel finalizzatore, poiché potrebbero essere stati finalizzati.

---

Di recente mi è capitato di guardare la Destructors della pagina Guida per programmatori C #. Mostra che mi sono sbagliato nella mia risposta, sopra. In particolare, c'è una differenza tra distruttore e finalizzatore:

class Car
{
    ~Car()  // destructor
    {
        // cleanup statements...
    }
}

è equivalente a

protected override void Finalize()
{
    try
    {
        // Cleanup statements...
    }
    finally
    {
        base.Finalize();
    }
}

Answer 4

Penso che la confusione sia dovuta al fatto che nel tuo esempio non stai rilasciando risorse non gestite. Questi devono anche essere rilasciati quando lo smaltimento viene chiamato tramite Garbage Collection e verrebbero rilasciati all'esterno il controllo per smaltimento . Vedi l'esempio MSDN relativo a rilasciando risorse non gestite . L'altro che potrebbe / dovrebbe accadere al di fuori del controllo è una chiamata a qualsiasi metodo Dispose della classe base.

Dall'articolo citato:

   protected override void Dispose(bool disposing) 
   {
      if (disposing) 
      {
         // Release managed resources.
      }
      // Release unmanaged resources.
      // Set large fields to null.
      // Call Dispose on your base class.
      base.Dispose(disposing);
   }

Answer 5

All'interno dell'if (eliminazione) si suppone di chiamare dispose / close su oggetti gestiti che hanno risorse non gestite (ad esempio connessioni al database). Quando il finalizzatore viene chiamato, questi oggetti non sono più raggiungibili in modo che gli oggetti stessi possano essere finalizzati e tu non è necessario chiamare dispose su di loro. Anche l'ordine di finalizzazione è indeterminato, quindi è possibile che si chiami dispose su oggetti già disposti.

Answer 6

L'esempio seguente mostra come creare una classe di risorse che implementa l'interfaccia IDisposable: https://msdn.microsoft.com/en-us/library/System.IDisposable.aspx

Nella funzione Dispose (bool disposing): se disposing è uguale a true, il metodo è stato chiamato direttamente o indirettamente dal codice. Le risorse gestite e non gestite possono essere eliminate. Se disposing equivale a false, il metodo è stato chiamato dal runtime dall'interno del finalizzatore e non è necessario fare riferimento ad altri oggetti. È possibile eliminare solo le risorse non gestite.