Implementazione di IDisposable correttamente

Nelle mie lezioni implemento IDisposable come segue:

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, la mia analisi del codice dice di implementare IDisposable correttamente, ma non sono sicuro di cosa ho fatto di sbagliato qui.
Il testo esatto è il seguente:

CA1063 Implementare IDisposable correttamente Fornire un'implementazione scavalcabile di Dispose (bool) su 'Utente' o contrassegnare il tipo come sigillato. Una chiamata a Dispose (false) dovrebbe solo ripulire le risorse native. Una chiamata a Dispose (true) dovrebbe ripulire sia le risorse gestite che quelle native. stman User.cs 10

Per riferimento: CA1063: Implementare IDisposable correttamente

Ho letto questa pagina, ma temo di non capire davvero cosa debba essere fatto qui.

Se qualcuno può spiegare in termini più lusinghieri quale sia il problema e / o come debba essere implementato IDisposable, questo sarà di grande aiuto!

Questa sarebbe l'implementazione corretta, anche se non vedo nulla che devi smaltire nel codice che hai pubblicato. Devi solo implementare IDisposablequando:

1. Hai risorse non gestite
2. Ti stai aggrappando a riferimenti di cose che sono essi stessi disponibili.

Nulla nel codice che hai pubblicato deve essere eliminato.

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

Prima di tutto, non c'è bisogno di "clean up" strings ed ints - esse verranno prese cura di automaticamente dal garbage collector. L'unica cosa che deve essere ripulita Disposesono le risorse non gestite o le risorse gestite che implementano IDisposable.

Tuttavia, supponendo che questo sia solo un esercizio di apprendimento, il modo consigliato per implementare IDisposableè aggiungere un "fermo di sicurezza" per garantire che qualsiasi risorsa non venga smaltita due volte:

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

L'esempio seguente mostra le migliori pratiche generali per implementare l' IDisposableinterfaccia. Riferimento

Tieni presente che hai bisogno di un distruttore (finalizzatore) solo se hai risorse non gestite nella tua classe. E se aggiungi un distruttore, dovresti sopprimere la finalizzazione in Dispose , altrimenti i tuoi oggetti risiederanno in memoria per due cicli di immondizia (Nota: leggi come funziona la finalizzazione ). Di seguito esempio elaborato tutto sopra.

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

IDisposableesiste per fornire un mezzo per ripulire le risorse non gestite che non verranno ripulite automaticamente dal Garbage Collector.

Tutte le risorse che stai "ripulendo" sono risorse gestite e come tale il tuo Disposemetodo non sta realizzando nulla. La tua classe non dovrebbe implementarsi IDisposableaffatto. Il Garbage Collector si prenderà cura di tutti quei campi da solo.

È necessario utilizzare il modello monouso in questo modo:

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

Non è necessario eseguire la Userlezione IDisposablepoiché la classe non acquisisce risorse non gestite (file, connessione al database, ecc.). Di solito, contrassegniamo le classi come IDisposablese avessero almeno un IDisposablecampo o / e proprietà. Durante l'implementazione IDisposable, meglio inserirlo secondo lo schema tipico di Microsoft:

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 è implementato ogni volta che si desidera una garbage collection deterministica (confermata).

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

Quando si crea e si utilizza la classe Users, utilizzare il blocco "using" per evitare di chiamare in modo esplicito il metodo dispose:

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

la fine del blocco usando l'oggetto Users creato verrà eliminata dal metodo implicito invoke of dispose.

Vedo molti esempi del pattern Microsoft Dispose che è in realtà un anti-pattern. Come molti hanno sottolineato il codice nella domanda non richiede affatto IDisposable. Ma se hai intenzione di implementarlo, non utilizzare il modello Microsoft. Una risposta migliore sarebbe seguire i suggerimenti in questo articolo:

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

L'unica altra cosa che potrebbe essere utile è sopprimere l'avviso di analisi del codice ... https://docs.microsoft.com/en-us/visualstudio/code-quality/in-source-suppression-overview?view=vs- 2017