Answer

Garbage collection (Garbage Collection, GC) in Visual Basic .NET is an automatic memory management process that frees unused objects, preventing memory leaks. When objects are created, memory is allocated on the managed heap, and when there are no more references to the object, the garbage collector will eventually release the occupied resources.

Features:

• Manually invoking GC is generally not recommended; trust the control to the .NET environment.
• Classes can implement the Finalize method to clean up unmanaged resources, but it is safer to use the IDisposable interface and the Dispose method.
• Use the Using construct for automatic invocation of the Dispose method.
• Finalizers do not run immediately after the reference is lost, but only when the GC deems it necessary.

Example code using Dispose:

Public Class FileManager
    Implements IDisposable

    Private disposed As Boolean = False

    ' ... unmanaged resource

    Public Sub Dispose() Implements IDisposable.Dispose
        If Not disposed Then
            ' Cleanup resources
            disposed = True
        End If
        GC.SuppressFinalize(Me)
    End Sub

    Protected Overrides Sub Finalize()
        Dispose()
        MyBase.Finalize()
    End Sub
End Class

Trick Question

Can you be sure that an object's finalizer will be called when the program ends?

Incorrect answer: Yes, the finalizer is called automatically when the object is no longer needed.

Correct answer: No, the finalizer invocation is not guaranteed when the process ends. Finalizers will only be called if the GC manages to process them. For reliable resource release, always use Dispose.

Example:

' Using the Using construct for guaranteed resource cleanup
Using mgr As New FileManager()
    ' Working with the resource
End Using

Examples of real mistakes due to lack of knowledge on the topic

---

Story
In a file processing project, temporary files were not deleted as it relied only on the finalizer. With a large volume of files — there was a file system overflow until an explicit call to Dispose was implemented.

---

Story
A developer manually invoked GC.Collect() after each operation — this severely slowed down application performance, as frequent garbage collections consumed a lot of CPU.

---

Story
In large web applications, one of the services improperly implemented the Dispose pattern and did not call GC.SuppressFinalize(). This led to double cleanup of objects, causing unexpected crashes and resource leaks.