Chiarimenti sull'implementazione di IDisposable

[LukeSky]

Ciao a tutti, vorrei dei chiarimenti sull'implementazione dell'interfaccia IDisposable. Vi posto un codice di esempio:

Public Partial Class MainWindow
    Inherits Window
    Public Sub New()
        InitializeComponent()
        Dim a As New TestObject()
        a.Dispose()
    End Sub

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        GC.Collect()
    End Sub
End Class

Public Class TestObject
    Implements IDisposable
    Public Sub New()
        'Costruttore
        Console.WriteLine("Costruttore")
    End Sub

    Protected Overrides Sub Finalize()
        Try
            'Finalize
            Dispose(False)
            Console.WriteLine("Distruttore")
        Finally
            MyBase.Finalize()
        End Try
    End Sub

    #Region "IDisposable"

    Protected _disposed As Boolean

    Public Sub Dispose()
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub

    Protected Sub Dispose(disposing As Boolean)
        If Not _disposed Then
            If disposing Then
                Console.WriteLine("Dispose")
            End If
            _disposed = True
        End If
    End Sub

    #End Region
End Class

Facendo le prove con questo codice ho visto che se io metto a commento la chiamata esplicita al metodo "Dispose" (a.Dispose) nel momento in cui forzo GC.Collect viene invocato il distruttore dell'oggetto TestObject; quindi, se non ho capito male, l'oggetto viene cancellato fisicamente dalla memoria (come è giusto che sia). Mentre se io richiamo il metodo "Dispose" e successivamente forzo il GC.Collect il distruttore della classe non viene più invocato e questo perché, se non ho capito male, l'istruzione "GC.SuppressFinalize(this)" comunica al GC che non è necessario fare il "finalize" dell'oggetto perché è già stato fatto il Dispose...ma facendo in questo modo l'oggetto fisicamente risiede ancora in memoria? Oppure viene comunque cancellato? Se si, in che modo?

Ho inserito il "GC.SuppressFinalize" perché in rete ho visto che molte implementazioni dell'interfaccia IDisposable lo consigliano, è effettivamente un vantaggio? Quale è il modo migliore di implementare IDisposable?

Vi ringrazio in anticipo per ogni chiarimento in merito.

[URANIO]

Ho giocato poco sinceramente con la GC, ma a quanto ho capito "finalize" non cancella l'oggetto ma rende disponibile al l'oggetto al GC.
La prossima volta che gira la GC eliminerà l'oggetto.
Il codice che hai scritto fa quello che avviene di default.

[LukeSky]

Hai ragione...facendo altri test credo di aver capito come si comporta.

Come dici tu, quando passa nel "finalize" in realtà l'oggetto viene solo "marcato" come cancellabile dal garbage collector che effettivamente lo elimina al successivo ciclo di riciclo.

Il SuppressFinalize invece ottimizza le cose perché comunica al GC che può cancellare fin da subito l'oggetto in quanto è già stato fatto il dispose (e quindi il rilascio di eventuali risorse collegate all'oggetto).