Prawidłowe wdrażanie IDisposable

W moich zajęciach implementuję IDisposable w następujący sposób:

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

W VS2012 moja analiza kodu mówi, aby poprawnie zaimplementować IDisposable, ale nie jestem pewien, co zrobiłem źle.
Dokładny tekst jest następujący:

CA1063 Implement IDisposable poprawnie Podaj możliwą do zastąpienia implementację Dispose (bool) w polu „User” lub oznacz typ jako zapieczętowany. Wywołanie Dispose (false) powinno tylko wyczyścić zasoby natywne. Wywołanie Dispose (true) powinno oczyścić zarówno zasoby zarządzane, jak i natywne. stman User.cs 10

Dla porównania: CA1063: poprawnie zaimplementuj IDisposable

Przeczytałem tę stronę, ale obawiam się, że tak naprawdę nie rozumiem, co należy tutaj zrobić.

Jeśli ktoś może wyjaśnić w bardziej lamerski sposób, na czym polega problem i / lub jak należy wdrożyć IDisposable, to naprawdę pomoże!

To byłaby prawidłowa implementacja, chociaż nie widzę niczego, co musisz usunąć w opublikowanym kodzie. Musisz wdrożyć tylko IDisposablewtedy, gdy:

1. Masz niezarządzane zasoby
2. Trzymasz się odniesień do rzeczy, które same są jednorazowe.

Żadna część przesłanego kodu nie musi zostać usunięta.

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

Przede wszystkim nie musisz „czyścić” stringi int-ów - zostaną one automatycznie załatwione przez garbage collectora. Jedyne, co należy wyczyścić, Disposeto niezarządzane zasoby lub zarządzane zasoby, które implementują IDisposable.

Zakładając jednak, że jest to tylko ćwiczenie edukacyjne, zalecanym sposobem implementacji IDisposablejest dodanie „bezpiecznika”, aby upewnić się, że żadne zasoby nie są usuwane dwukrotnie:

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

Poniższy przykład przedstawia ogólne najlepsze rozwiązania dotyczące implementacji IDisposableinterfejsu. Odniesienie

Pamiętaj, że potrzebujesz destruktora (finalizatora) tylko wtedy, gdy masz niezarządzane zasoby w swojej klasie. A jeśli dodasz destruktor, powinieneś pominąć Finalizację w Dispose , w przeciwnym razie spowoduje to, że twoje obiekty będą znajdować się w pamięci przez dwa cykle bezużyteczne (uwaga: przeczytaj, jak działa finalizacja ). Poniższy przykład omówi wszystko powyżej.

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

IDisposableistnieje, aby zapewnić Ci środki do czyszczenia niezarządzanych zasobów, które nie będą czyszczone automatycznie przez moduł wyrzucania elementów bezużytecznych.

Wszystkie zasoby, które „czyścisz”, są zasobami zarządzanymi, a zatem Twoja Disposemetoda nic nie daje. Twoja klasa nie powinna w ogóle implementować IDisposable. Garbage Collector sam zadba o wszystkie te pola.

Musisz użyć wzoru jednorazowego w następujący sposób:

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);
}

Nie musisz zajmować się swoją Userklasą, IDisposableponieważ nie pobiera ona żadnych niezarządzanych zasobów (plików, połączeń z bazą danych itp.). Zwykle oznaczamy klasy tak, IDisposablejakby miały przynajmniej jedno IDisposablepole lub / i właściwość. Podczas implementacji IDisposablelepiej ująć to zgodnie z typowym schematem Microsoftu:

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 jest implementowane zawsze, gdy chcesz deterministycznego (potwierdzonego) wyrzucania elementów bezużytecznych.

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

Podczas tworzenia i używania klasy Users użyj bloku "using", aby uniknąć jawnego wywoływania metody dispose:

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

koniec using bloku utworzonego obiektu Users zostanie usunięty przez niejawne wywołanie metody dispose.

Widzę wiele przykładów wzorca Microsoft Dispose, który jest tak naprawdę anty-wzorcem. Jak wielu zwróciło uwagę, kod w pytaniu w ogóle nie wymaga IDisposable. Ale jeśli zamierzasz to zaimplementować, nie używaj wzorca Microsoft. Lepszą odpowiedzią byłoby postępowanie zgodnie z sugestiami zawartymi w tym artykule:

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

Jedyną inną rzeczą, która prawdopodobnie byłaby pomocna, jest pominięcie tego ostrzeżenia dotyczącego analizy kodu ... https://docs.microsoft.com/en-us/visualstudio/code-quality/in-source-suppression-overview?view=vs- 2017