Significant Garbage Collector Changes in .NET

In this blog, we’ll discuss garbage collection guidelines. The .NET Framework provides garbage functionality and it is used to manage memory for all applications. When we use the New operator to create an object, at that time the object’s memory is acquired from the managed heap. When the GC managed that adequate garbage has accrued that it is sufficient to do that, which are performing a collection to free unused memory. All processes are handled by the. NET, but here a number of things you need to take care of that.

Table of Content

What is Garbage Collector?

Garbage Collection is an automatic process to identify and delete the objects from Heap memory that are not in use. Garbage Collector frees the space after removing unused objects.

Garbage Collection is a process that was performed by memory management functionality automatically. The Garbage Collector (GC) finds the unused and unnecessary objects and deletes them to reclaim the memory.

Advantages of Garbage Collection

1. You don’t need to delete the unused memory manually while developing your application.

2. It also allocates objects on the managed heap competently.

3. When objects are no extensively used then it will reclaim those objects by clearing their memory, and keeps the memory available for future allocations.

4. Managed objects and unnecessary data automatically get Delete content to start with, so their constructors do not have to initialize every data field.

5.Garbage collection was also provided memory safety by making sure that an object cannot use the content of another object.

Disadvantages of Garbage Collection

The main disadvantages to using a garbage collector, as per my view:

1. Require able to the cleanup of over data at times, it is handy to say "I'm done with this, and I want it cleaned NOW". With a Garbage collector, this typically means forcing the Garbage collector to clean up everything from over system, or just wait before that was ready - both of these.

2. Potential performance issues arise from the non-deterministic operation of the GC. This can be particularly difficult for things such as real-time simulations or games.

Algorithm of Garbage Collection

When we run the application at that time operator calls a new object for taking data from the operator, there might not be enough space left in the managed heap to allocate for the object. In the case of short space, common language runtime performs garbage collection, CLR garbage collector also stands for Ephemeral Garbage Collector (Generation based Garbage Collection). CLR GC makes the following guess about the code. The new object is always short compare to the old object. The lifetime of an old object is likely to be bigger. Collecting a portion of the memory (heap) is equally faster than collecting the whole heap.

Conditions for applying Garbage Collection

1. Garbage collection occurred when one of the below conditions is true.
2. The system has low physical memory, like RAM.
3. The memory that was used by allocated objects. The memory is allocated by the processor. The garbage Collection opening is continuously adjusted as the process runs.
4. The Garbage Collection. The collect method is called every case, no need to call a collect method separately because the garbage collector runs constantly. This method is mostly used for testing.

Let’s understand about the generation of garbage collection

Here are three generations of the Garbage Collection and it is listed out below.

Generation 0: All the shorted objects such as Temp variables contained in Gen 0 of the mass memory. Here all newly allocated objects are also gen 0 objects implicitly unless they are big objects. In general, the 0 Gen have a big collection of regularity.

Generation 1: If space active by some generation 0 objects that are not released in a garbage collection run, then these objects get moved to generation 1. In this generation objects are sort of buffer between the short object in Gen 0 and the big objects in gen 2.

Generation 2: If space used by some gen 1 objects are not released in the again garbage collection run, then these objects get moved to generation 2. The objects in second generation are long-lived such as static objects that remained in the heap memory for the whole process duration.

GC.MaxGeneration property of the Garbage Collection class is given as follows:

using System; 
public class GCDemo { 
    public static void Main(string[] args) 
    { 
        Console.WriteLine("The no. of generations in Garbage collection: " + 
                                           GC.MaxGeneration); 
    } 
} 
GetTotalMemory and GetGeneration
using System;  
class BaseGC  
{  
    public void Dis()  
    {  
        Console.WriteLine("Example of the Garbage Collection");  
    }  
}  
class GCExample2  
{  
    public static void Main (string [] args)  
    {  
        try  
        {  
            Console.WriteLine("Total Memory:" + GC.GetTotalMemory(false));  
            BaseGC oBaseGC = new BaseGC();  
            Console.WriteLine("Base GC Generation is :" + 			GC.GetGeneration(oBaseGC));  
            Console.WriteLine("Total Memory:" + GC.GetTotalMemory(false));  
        }  
        catch (Exception oEx)  
        {  
            Console.WriteLine("Error:" + oEx.Message);  
        }  
    }  
}  		

Here GetTotalMemory this method shows the total number of memories occupied by the different resources. Here we have added one more managed code object in the heap memory. After including, the size of the memory has extended.

How to implement garbage collection in .NET, let’s understand using step by step simple example.

using System;
class   
{  
    public int Add(int x, int y)  
    {  
        return (x + y);  
    }  
    public int Sub(int x, int y)  
    {  
        return (x - y);  
    }  
    public int Mult(int x, int y)  
    {  
        return (x * y);  
    }  
    public int Divide(int x, int y)  
    {  
        return (x / y);  
    }  
}  
class GCExample3  
{  
    public static void Main(string[] args)  
    {  
         o = new ();  
        Console.WriteLine(" then right now object on " + GC.GetGeneration(o) + " Generation");  
        Console.WriteLine("Garbage Collection Occurred in 0th Generation:" + GC.CollectionCount(0));  
        Console.WriteLine("Garbage Collection Occurred in 1th Generation:" + GC.CollectionCount(1));  
        Console.WriteLine("Garbage Collection Occurred in 2th Generation:" + GC.CollectionCount(2));  
        GC.Collect(0);  
        Console.WriteLine("Garbage Collection Occurred in 0th Generation:" + GC.CollectionCount(0));  
    }  
}

Conclusion

This blog helps you in understanding the concept of garbage collector in Asp.Net. This is used to remove the unused objects from the heap memory on the website. When we use the new operator to create an object, at that time the object’s memory is acquired from the managed heap. We had a look at the different generations of Garbage Collection and implementations and their use cases.