Wie implementieren Sie IDisposable korrekt

Nein, Dispose-Methoden sind nicht eine Verschwendung von Zeit.

Das dispose-Muster ist es zu ermöglichen, einen Anrufer zu bereinigen, eine Klasse, sobald Sie mit Ihr fertig sind, anstatt zu warten, für die Gesamtwertung zu sammeln. Die Verzögerung spielt keine Rolle, viel für nur heap-Speicher, weshalb grundlegende Klassen wie String nicht implementieren. Was zu Entsorgen ist nützlich, jedoch ist die Reinigung unmanaged Ressourcen. Irgendwo intern die Dataset-Klasse ist mit eine nicht verwaltete Ressource, so dass es bietet eine dispose-Methode auf, damit Sie um ihn wissen zu lassen, wenn nicht verwaltete Ressourcen freigegeben werden können.

Wenn das Muster gefolgt wurde, richtig Dataset wird auch ein finalizer (oder eine Unterklasse wird), was bedeutet, dass, wenn Sie nicht entsorgen Sie es manuell, schließlich die GC laufen würde, der finalizer würde aufgerufen werden, und die nicht verwaltete Ressource würde aufgeräumt werden, dass Art und Weise. Dieser nicht verwaltete Ressource wichtig sein könnte, obwohl, Stell dir vor, es war eine lock-Datei, oder eine Datenbank-Verbindung, die Sie nicht wirklich wollen, hängen herum und warten auf die GC zu laufen, bevor Sie Sie wiederverwenden können Ihre Datenbank-Verbindung. Entsorgen, stellt einen deterministischen Weg von Aufräumen von Ressourcen, wenn Sie fertig sind, anstatt sich auf die nicht-deterministische GC.

Als für die Einstellung der Variablen auf null in einer dispose-Methode. Fast alle Fälle, es wäre sinnlos. Einstellung einer Variablen auf null löscht eine Referenz auf die variable, die machen es für die garbage collection freigegeben (wenn die Letzte Referenz), aber als Sie die Entsorgung von der Klasse sowieso, Sie sind wahrscheinlich zu sein out-of-scope für die enthaltende Klasse, so die interne Klasse, erhalten die Berechtigung für die Sammlung sowieso.

Wenn Sie member-Variablen innerhalb der Klasse, die sind Einweg, die Sie erstellt haben (und nicht nur Referenzen, die Sie halten), dann sollten Sie immer rufen Sie dispose auf, Sie von Ihrer eigenen Klasse die dispose-Methode, aber nicht die Mühe, stellt Sie auf null.

InformationsquelleAutor Simon P Stevens

Garbage truck kommt zu meinem Bereich jede Woche, aber eben nicht meinen Müll, wenn ich meine Mülltonne in einer Weise, die es sammeln kann.

Sollten Sie entfernen Sie einfach alle unerwünschten Ereignis-Abonnements -, Referenz-und löschen nicht verwalteter Handler auf. Dann Garbage Collector kümmert sich um den rest.

Beispiel unten zeigen die allgemein beste Praxis zu implementieren IDisposable-Schnittstelle. Referenz : https://msdn.microsoft.com/en-us/library/system.idisposable.dispose(v=vs. 110).aspx

public class DisposeExample
{
    //A base class that implements IDisposable. 
    //By implementing IDisposable, you are announcing that 
    //instances of this type allocate scarce resources. 
    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. 
        protected virtual 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);
        }
    }
    public static void Main()
    {
        //Insert code here to create 
        //and use the MyResource object.
    }
}

InformationsquelleAutor CharithJ