[.NET] IDisposable - oggetti managed e non

[0rph3n]

Ciao a tutti,
allora ho creato una classe che implementa l'interfaccia IDisposable.
Dalla pagina che ho linkato, si evince come il codice per sbarazzarsi degli oggetti managed debba essere rinchiuso in un if che ne impedisce l'esecuzione qualora l'oggetto venga triturato dal garbage collector.
Ora vengo al dunque:
dalle mie fetide conoscenze non mi risulta, ma ci sono risorse unmanaged all'interno del framework .net? se si quali sono?
gli oggetti che non implementano l'interfaccia IDisposable e che quindi non hanno il metodo Dispose, come vanno distrutti?

grassie
'iao

[RaouL_BennetH]

Originariamente inviato da 0rph3n

Ciao a tutti,
allora ho creato una classe che implementa l'interfaccia IDisposable.
Dalla pagina che ho linkato, si evince come il codice per sbarazzarsi degli oggetti managed debba essere rinchiuso in un if che ne impedisce l'esecuzione qualora l'oggetto venga triturato dal garbage collector.
Ora vengo al dunque:
dalle mie fetide conoscenze non mi risulta, ma ci sono risorse unmanaged all'interno del framework .net? se si quali sono?
gli oggetti che non implementano l'interfaccia IDisposable e che quindi non hanno il metodo Dispose, come vanno distrutti?

grassie
'iao

Ciao

Da quel poco che so di .NET, dato che lo sto studiando da poco, puoi garantirti una chiamata a Dispose() utilizzando qualcosa del genere:

try

  {

     using(Oggetto myObj = new Object)
    {
            //codice vario
    } //in questo momento viene garantita la chiamata a Dispose()
      //ma ovviamente non si può predeterminare quando il GC distruggerà l'oggetto
  }

catch(Exception ex)
{
    //gestisci l'eccezione
}

C'è anche un modo per utilizzare i puntatori, che riguarda una sezione chiamata "unsafe code", ma purtroppo non ci sono ancora arrivato a livello di studio.

[0rph3n]

Originariamente inviato da RaouL_BennetH

Ciao

Da quel poco che so di .NET, dato che lo sto studiando da poco, puoi garantirti una chiamata a Dispose() utilizzando qualcosa del genere:

cut

Ciao
grazie della risposta anche se io non voglio sapere come garantirmi una chiamata al metodo Dispose() da parte del garbage collector.
Anche perche il garbage collector non chiama quel metodo, ma esegue il distruttore dell'oggetto (che chiama il metodo privato Dispose(bool)).
Comunque riporto l'esempio che si può trovare su MSDN IDisposable, così che si abbia una base comune:
in verde i commenti di MSDN in rosso i miei (è più una traduzione che altro)

        // 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.
        // Questo è il metodo pubblico da chiamare per distruggere
        // l'oggetto.
        // A sua volta chiama il metodo privato Dispose(bool)
        // passandogli true come parametro e indicandogli quindi
        // di sbarazzarsi sia delle risorse managed
        // sia di quelle non managed.
        // Infine chiama il metodo SupressFinalize del garbage collector
        // per togliere questo oggetto dalla coda
        // ed evitare una seconda e quindi inutile distruzione.
        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.
        // Questo è il metodo che si occupa di smaltire
        // le risorse.
        // In questa implementazione può essere chiamato:
        //  sia dal metodo pubblico Dispose() (e quindi da codice)
        //  sia dal distruttore della classe (e quindi dal garbage collector).
        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.
        // Questo è il distruttore della classe.
        // Viene invocato dal garbage collector.
        // A sua volta chiama il metodo privato Dispose(bool)
        // passandogli false come parametro e indicandogli quindi
        // di sbarazzarsi solo delle risorse non managed,
        // in quanto quelle managed verranno distrutte dal garbage collector.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
    }

Originariamente inviato da RaouL_BennetH

C'è anche un modo per utilizzare i puntatori, che riguarda una sezione chiamata "unsafe code", ma purtroppo non ci sono ancora arrivato a livello di studio.

quella sezione dovrebbe riferirsi alle risorse non managed, il cui caso è trattato nell'esempio che ho postato sopra!

comunque ripeto le mie domande iniziali:

• esistono oggetti non managed all'interno del framework .net?
• se si, quali sono?
• come si distruggono gli oggetti che non implementano l'interfaccia IDisposable e che quindi non hanno il metodo Dispose()?

[RaouL_BennetH]

Originariamente inviato da 0rph3n

Ciao
grazie della risposta anche se io non voglio sapere come garantirmi una chiamata al metodo Dispose() da parte del garbage collector.
Anche perche il garbage collector non chiama quel metodo, ma esegue il distruttore dell'oggetto (che chiama il metodo privato Dispose(bool)).
Comunque riporto l'esempio che si può trovare su MSDN IDisposable, così che si abbia una base comune:
in verde i commenti di MSDN in rosso i miei (è più una traduzione che altro)

        // 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.
        // Questo è il metodo pubblico da chiamare per distruggere
        // l'oggetto.
        // A sua volta chiama il metodo privato Dispose(bool)
        // passandogli true come parametro e indicandogli quindi
        // di sbarazzarsi sia delle risorse managed
        // sia di quelle non managed.
        // Infine chiama il metodo SupressFinalize del garbage collector
        // per togliere questo oggetto dalla coda
        // ed evitare una seconda e quindi inutile distruzione.
        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.
        // Questo è il metodo che si occupa di smaltire
        // le risorse.
        // In questa implementazione può essere chiamato:
        //  sia dal metodo pubblico Dispose() (e quindi da codice)
        //  sia dal distruttore della classe (e quindi dal garbage collector).
        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.
        // Questo è il distruttore della classe.
        // Viene invocato dal garbage collector.
        // A sua volta chiama il metodo privato Dispose(bool)
        // passandogli false come parametro e indicandogli quindi
        // di sbarazzarsi solo delle risorse non managed,
        // in quanto quelle managed verranno distrutte dal garbage collector.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
    }

quella sezione dovrebbe riferirsi alle risorse non managed, il cui caso è trattato nell'esempio che ho postato sopra!

comunque ripeto le mie domande iniziali:

• esistono oggetti non managed all'interno del framework .net?
• se si, quali sono?
• come si distruggono gli oggetti che non implementano l'interfaccia IDisposable e che quindi non hanno il metodo Dispose()?

Eheh, scusami, davvero non avevo colto il senso delle tue domande, anzi, ti ringrazio io per avermi insegnato qualcosa in più

[0rph3n]

Originariamente inviato da RaouL_BennetH

Eheh, scusami, davvero non avevo colto il senso delle tue domande, anzi, ti ringrazio io per avermi insegnato qualcosa in più

figurati , quando si può è bello.
adesso spero che arrivi qualcuno che mi sappia illuminare
intanto io continuerò a cercare un po' in giro per vedere se trovo qualcosa!

'iao