What is the use of garbage control?

In C# all objects (i.e. instances of classes) are allocated in an area of memory known as the managed heap.

Heap memory is a finite resource and therefore needs to be managed in some way to avoid the possibility that you might run out of it whilst a program is running.

Ideally, when an object is no longer needed, you'd like to reclaim the memory it was using so that it's available for use by new objects.

In C++ you have to manage heap memory yourself using the 'new' and 'delete' keywords. If you forget to call 'delete' when an object is no longer required this can lead to a so called 'memory leak'.

In C# (and .NET generally) you are relieved of the need to manage memory yourself so that you can concentrate instead on the logic of the program.

The Common Language Runtime allocates memory for new objects as needed and, periodically, the 'garbage collector' identifies objects which are no longer needed, calls their destructors (if they have any), reclaims the memory they were using and compacts the memory used by the remaining objects, so that new objects can be allocated at the end.

Here's a short program which shows the garbage collector (GC) in action:

using System;

class MyClass

{

public MyClass()

{

Console.WriteLine("New object allocated");

}

public void DoSomething()

{

Console.WriteLine("Object is doing something ...");

}

~MyClass()

{

Console.WriteLine("Object deallocated");

}

class Program

{

static void Main()

{

MyMethod();

Console.ReadKey(true);

Console.WriteLine("After a pause ...");

}

static void MyMethod()

{

MyClass mc = new MyClass();

mc.DoSomething();

}

}

The output is:

New object allocated

Object is doing something ...

After a pause ...

Object deallocated

After MyMethod() ends, there are no longer any references to the MyClass object and so it is marked for garbage collection. However, as there is no pressure to allocate new objects, its destructor is not run and its memory reclaimed until after a key is pressed.

Normally, it doesn't matter much when the GC runs. However, in some cases, this indeterminate behavior can be a problem and in those cases you can trigger an immediate garbage collection by calling GC.Collect().

So, if you change the Main method to this:

static void Main()

{

MyMethod();

GC.Collect();

Console.ReadKey(true);

Console.WriteLine("After a pause ...");

}

the output now is :

New object allocated

Object is doing something ...

Object deallocated

After a pause ...

showing that the object has now been de-allocated before the key is pressed.

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes11y ago
In C# all objects (i.e. instances of classes) are allocated in an area of memory known as the managed heap.

Heap memory is a finite resource and therefore needs to be managed in some way to avoid the possibility that you might run out of it whilst a program is running.

Ideally, when an object is no longer needed, you'd like to reclaim the memory it was using so that it's available for use by new objects.

In C++ you have to manage heap memory yourself using the 'new' and 'delete' keywords. If you forget to call 'delete' when an object is no longer required this can lead to a so called 'memory leak'.

In C# (and .NET generally) you are relieved of the need to manage memory yourself so that you can concentrate instead on the logic of the program.

The Common Language Runtime allocates memory for new objects as needed and, periodically, the 'garbage collector' identifies objects which are no longer needed, calls their destructors (if they have any), reclaims the memory they were using and compacts the memory used by the remaining objects, so that new objects can be allocated at the end.

Here's a short program which shows the garbage collector (GC) in action:

using System;

class MyClass
{
public MyClass()
{
Console.WriteLine("New object allocated");
}

public void DoSomething()
{
Console.WriteLine("Object is doing something ...");
}

~MyClass()
{
Console.WriteLine("Object deallocated");
}
}

class Program
{
static void Main()
{
MyMethod();
Console.ReadKey(true);
Console.WriteLine("After a pause ...");
}

static void MyMethod()
{
MyClass mc = new MyClass();
mc.DoSomething();
}
}

The output is:

New object allocated
Object is doing something ...
After a pause ...
Object deallocated

After MyMethod() ends, there are no longer any references to the MyClass object and so it is marked for garbage collection. However, as there is no pressure to allocate new objects, its destructor is not run and its memory reclaimed until after a key is pressed.

Normally, it doesn't matter much when the GC runs. However, in some cases, this indeterminate behavior can be a problem and in those cases you can trigger an immediate garbage collection by calling GC.Collect().

So, if you change the Main method to this:

static void Main()
{
MyMethod();
GC.Collect();
Console.ReadKey(true);
Console.WriteLine("After a pause ...");
}

the output now is :

New object allocated
Object is doing something ...
Object deallocated
After a pause ...

showing that the object has now been de-allocated before the key is pressed.
Joginder Banger11y ago
Hi Kalith Rahman
I assume you are familiar with c and C++ language. Suppose we are not assign any number
int i; By default value assign like '213245' In c language

int i; By default value assign 0. Not a garbage value.

In c language developer (programmer) worry about the memory because in c language have no garbage control.
In C# language no worry about the memory.