Garbage Collection C#

Aman Singh Parihar
3 min readJan 10, 2023
Garbage Collection
Photo by Tobias Tullius on Unsplash

Garbage collection is a background process which runs deterministically and cleans unreferenced managed objects from the memory.

Some definitions which are important to know are as follows:-

Heap:- Portion of memory where dynamically allocated objects resides.

Managed Heap:- Whenever we start any process or run our .NET code, it
reserves some space in the memory which is contiguous and
it’s called managed heap.

Those were the days when the developers would be required to release the memory which they have allocated for the objects.

It’s the developers responsibility to manage the memory, and this brings some issues during development.

  • If we create a new object but forget to delete it, it will persist in the memory for a long time even if we didn’t want to use it.
  • If our variable is referencing an object in the memory, and later that variable started referencing another object in the memory, then the previous object will persist in memory even if no variable is referencing this object. It’s called memory leak. Object is not referenced by any variable and also not required but still in memory.

To overcome these scenarios, .NET came up with the garbage collector, which will take care of deleting the objects from the memory.

But, the garbage collector is limited to allocate or release the memory of managed code only, it does not allocate or release the unmanaged memory.

Managed code written in the .NET might access unmanaged code.

  • for ex:- Connecting with database using SQL, Oracle classes, Network calls made from managed code, accessing files.

Even though we are writing the managed code, but this code is using the unmanaged code. So, as a developer it’s our responsibility to release the memory once the work of these objects are completed.

How do we release the memory then?

NET provides the IDisposable interface for the types (example:- class) which are using the unmanaged code, for ex, network calls, database connection etc.

Those types needs to implement IDisposable interface and provides the implementation of the Dispose() method and write their own logic to release the memory.

And our task as a developer is that once we are done with these objects, we should call the dispose method on these objects.

.NET also provides a Finalize method, in case developer forgets to call the dispose method on this object.

GC releases the memory even if we forget to call the dispose method, if that class also implements the finalize, but the crux here is that finalize in indeterministic and dispose is deterministic.

It means we have control over the dispose method, when to call. But that finalize will be in hand of GC, when it calls.

var fileProcessor = new FileProcessor();
fileProcessor.Dispose();

class FileProcessor : IDisposable
{
bool disposed = false;
FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);
public void Dispose()
{
Dispose(true);
//supress finalization
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (this.disposed)
return;

if (disposing)
{
fs.Dispose();
// Free any other managed objects here.
}
//free unmanaged objects here
//

this.disposed = true;
}
}

Sign up to discover human stories that deepen your understanding of the world.

Free

Distraction-free reading. No ads.

Organize your knowledge with lists and highlights.

Tell your story. Find your audience.

Membership

Read member-only stories

Support writers you read most

Earn money for your writing

Listen to audio narrations

Read offline with the Medium app

Aman Singh Parihar
Aman Singh Parihar

Written by Aman Singh Parihar

I work as a software engineer and having experience in web technologies. I like to share my knowledge with the community and aspire to learn cool things.

No responses yet

Write a response