IDisposable korrekt implementieren

In meinen Klassen implementiere ich IDisposable wie folgt:

public class User : IDisposable
{
    public int id { get; protected set; }
    public string name { get; protected set; }
    public string pass { get; protected set; }

    public User(int UserID)
    {
        id = UserID;
    }
    public User(string Username, string Password)
    {
        name = Username;
        pass = Password;
    }

    // Other functions go here...

    public void Dispose()
    {
        // Clear all property values that maybe have been set
        // when the class was instantiated
        id = 0;
        name = String.Empty;
        pass = String.Empty;
    }
}

In VS2012 heißt es in meiner Codeanalyse, IDisposable korrekt zu implementieren, aber ich bin mir nicht sicher, was ich hier falsch gemacht habe.
Der genaue Text lautet wie folgt:

CA1063 IDisposable korrekt implementieren Stellen Sie eine überschreibbare Implementierung von Dispose (bool) für 'User' bereit oder markieren Sie den Typ als versiegelt. Ein Aufruf von Dispose (false) sollte nur native Ressourcen bereinigen. Ein Aufruf von Dispose (true) sollte sowohl verwaltete als auch native Ressourcen bereinigen. stman User.cs 10

Als Referenz: CA1063: IDisposable korrekt implementieren

Ich habe diese Seite gelesen, aber ich fürchte, ich verstehe nicht wirklich, was hier zu tun ist.

Wenn jemand mehr Lamens erklären kann, was das Problem ist und / oder wie IDisposable implementiert werden sollte, wird das wirklich helfen!

Dies wäre die richtige Implementierung, obwohl ich in dem von Ihnen geposteten Code nichts sehe, was Sie entsorgen müssen. Sie müssen nur implementieren, IDisposablewenn:

1. Sie haben nicht verwaltete Ressourcen
2. Sie halten an Referenzen von Dingen fest, die selbst verfügbar sind.

Nichts in dem von Ihnen geposteten Code muss entsorgt werden.

public class User : IDisposable
{
    public int id { get; protected set; }
    public string name { get; protected set; }
    public string pass { get; protected set; }

    public User(int userID)
    {
        id = userID;
    }
    public User(string Username, string Password)
    {
        name = Username;
        pass = Password;
    }

    // Other functions go here...

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

    protected virtual void Dispose(bool disposing)
    {
        if (disposing) 
        {
            // free managed resources
        }
        // free native resources if there are any.
    }
}

Zunächst müssen Sie strings und ints nicht "bereinigen" - sie werden automatisch vom Garbage Collector erledigt. Das einzige, was bereinigt werden muss, Disposesind nicht verwaltete Ressourcen oder verwaltete Ressourcen, die implementiert werden IDisposable.

Unter der Annahme, dass dies nur eine Lernübung ist, wird empfohlen , IDisposableeinen "Sicherheitsverschluss" hinzuzufügen, um sicherzustellen, dass Ressourcen nicht zweimal entsorgt werden:

public void Dispose()
{
    Dispose(true);

    // Use SupressFinalize in case a subclass 
    // of this type implements a finalizer.
    GC.SuppressFinalize(this);   
}
protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing) 
        {
            // Clear all property values that maybe have been set
            // when the class was instantiated
            id = 0;
            name = String.Empty;
            pass = String.Empty;
        }

        // Indicate that the instance has been disposed.
        _disposed = true;   
    }
}

Das folgende Beispiel zeigt die allgemeine Best Practice zum Implementieren der IDisposableSchnittstelle. Referenz

Denken Sie daran, dass Sie einen Destruktor (Finalizer) nur benötigen, wenn Sie nicht verwaltete Ressourcen in Ihrer Klasse haben. Wenn Sie einen Destruktor hinzufügen, sollten Sie die Finalisierung in der Entsorgung unterdrücken , da sich Ihre Objekte sonst zwei Speicherzyklen im Speicher befinden (Hinweis: Lesen Sie, wie die Finalisierung funktioniert ). Das folgende Beispiel erläutert alles oben.

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.
    }
}

IDisposableEs gibt eine Möglichkeit, nicht verwaltete Ressourcen zu bereinigen, die vom Garbage Collector nicht automatisch bereinigt werden.

Alle Ressourcen, die Sie "bereinigen", sind verwaltete Ressourcen, und als solche erreicht Ihre DisposeMethode nichts. Ihre Klasse sollte überhaupt nicht implementieren IDisposable. Der Garbage Collector kümmert sich selbstständig um all diese Felder.

Sie müssen das Einwegmuster wie folgt verwenden:

private bool _disposed = false;

protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            // Dispose any managed objects
            // ...
        }

        // Now disposed of any unmanaged objects
        // ...

        _disposed = true;
    }
}

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

// Destructor
~YourClassName()
{
    Dispose(false);
}

Sie müssen Ihre UserKlasse nicht ausführen , IDisposableda die Klasse keine nicht verwalteten Ressourcen (Datei, Datenbankverbindung usw.) erhält . Normalerweise markieren wir Klassen so, als IDisposablehätten sie mindestens ein IDisposableFeld oder / und eine Eigenschaft. Sagen Sie es bei der Implementierung IDisposablebesser nach dem typischen Microsoft-Schema:

public class User: IDisposable {
  ...
  protected virtual void Dispose(Boolean disposing) {
    if (disposing) {
      // There's no need to set zero empty values to fields 
      // id = 0;
      // name = String.Empty;
      // pass = String.Empty;

      //TODO: free your true resources here (usually IDisposable fields)
    }
  }

  public void Dispose() {
    Dispose(true);

    GC.SuppressFinalize(this);
  } 
}

Idisposable wird immer dann implementiert, wenn Sie eine deterministische (bestätigte) Speicherbereinigung wünschen.

class Users : IDisposable
    {
        ~Users()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
            // This method will remove current object from garbage collector's queue 
            // and stop calling finilize method twice 
        }    

        public void Dispose(bool disposer)
        {
            if (disposer)
            {
                // dispose the managed objects
            }
            // dispose the unmanaged objects
        }
    }

Verwenden Sie beim Erstellen und Verwenden der Users-Klasse den Block "using", um zu vermeiden, dass die dispose-Methode explizit aufgerufen wird:

using (Users _user = new Users())
            {
                // do user related work
            }

Das Ende des mit dem Benutzerobjekt erstellten Verwendungsblocks wird durch implizites Aufrufen der Entsorgungsmethode entsorgt.

Ich sehe viele Beispiele für das Microsoft Dispose-Muster, das wirklich ein Anti-Muster ist. Wie viele darauf hingewiesen haben, erfordert der Code in der Frage überhaupt keine IDisposable. Wenn Sie es jedoch implementieren möchten, verwenden Sie bitte nicht das Microsoft-Muster. Eine bessere Antwort wäre, den Vorschlägen in diesem Artikel zu folgen:

https://www.codeproject.com/Articles/29534/IDisposable-What-Your-Mother-Never-Told-You-About

Das einzige andere, was wahrscheinlich hilfreich wäre, ist die Unterdrückung dieser Warnung zur Codeanalyse ... https://docs.microsoft.com/en-us/visualstudio/code-quality/in-source-suppression-overview?view=vs- 2017