Shulou(Shulou.com)06/01 Report--

This article mainly introduces the relevant knowledge of how to use the .NET garbage collector, the content is detailed and easy to understand, the operation is simple and fast, and it has a certain reference value. I believe you will gain something after reading this article on how to use the .NET garbage collector. Let's take a look.

What is the garbage collector in a .NET application?

The garbage collector is just a feature provided by CLR to help us clean up or destroy unused managed objects. It basically reclaims memory by cleaning or destroying these unused managed objects.

When a DotNet application runs, it creates multiple objects, and the application may not use some of them at a given time.

Therefore, for these objects, the garbage collector runs continuously as a background thread, and at specific intervals, it checks to see if there are any unused managed objects, and whether it finds that it is just cleaning up these objects and reclaiming memory.

Note: the garbage collector will destroy only unused managed objects. It does not clean up unmanaged objects.

.net garbage collector algebra?

Let's learn what the garbage collector generation is and how it affects the performance of the garbage collector.

In .NET, there are three generations. They are generation 0, generation 1 and generation 2.

Understand generation 0, generation 1 and generation 2

Suppose you have a simple application called App1. As soon as the application starts, five managed objects are created.

Whenever any new objects (new objects) are created, they are moved to a bucket called Generation 0. For a better understanding, see the following figure:

We know that the garbage collector runs continuously as a background thread to check for any unused managed objects so that memory can be reclaimed by cleaning them.

Now, suppose the application does not need two objects (Object1 and Object2). Therefore, the garbage collector destroys these two objects (Object1 and Object2) and reclaims the memory in the generation 0 bucket.

However, the application still needs the remaining three objects (Object3, Object4, and Object5).

Therefore, the garbage collector does not clean up these three objects. Therefore, what the garbage collector will do is that his three managed objects (Object3, Object4, and Object5) will be moved to the first generation bucket, as shown in the following figure.

Now, suppose your application creates two new objects (Object6 and Object7). As new objects, they should be created in the generation 0 bucket, as shown in the following figure.

Now, run the garbage collector again, which involves generation 0 storage buckets and checking the objects used. Assume that the application does not use these two objects (Object6 and Object7), so it will delete them and reclaim memory.

Now it goes to the first generation bucket and checks which objects are not in use. Assume that the application still needs Object4 and Object5, but not object 3.

So, what the garbage collector will do, it will destroy Object3 and reclaim memory, and it will move Objec4 and Object5 to third-generation buckets, as shown in the following figure.

What are the generations?

Generations are just what they define how long objects remain in memory. Now, the question you can think of is, why do we need generations?

Why do we need generations?

Typically, when we use large applications, they can create thousands of objects. Therefore, each object, if the garbage collector to check whether they really need it, this is a very cumbersome process.

By creating this class, if the object in the generation 2 bucket means that the garbage collector will reduce access to the bucket.

The reason is that if the object moves to Generation 2, it means that it will stay in memory for more time. There's no need to check them over and over again.

So, in a nutshell, we can say that Generation 0, Generation 1, and Generation 2 help improve the performance of the garbage collector. The better the objects in Generation 0, the better the performance, and use memory in the best way.

How do we use destructors in a class so that we end up in a dual garbage collector loop?

The garbage collector will only clean up managed code. In other words, for any type of unmanaged code, cleaning up must be provided by unmanaged code, and the garbage collector cannot control them to clean up memory.

For example, suppose you have a class called MyClass in VB6, and then you must expose some functions, such as CLeanUp (), in which you must write logic to clean up unmanaged code.

From the DotNet code, you just need to call the method CLeanUp () to start the cleanup. This, or the part from which cleanup is called, is the class destructor.

This seems to be the best place to write cleanup code. However, when writing cleanup in destructors, there is a big problem associated with it. Let's understand what the problem is.

When you define a destructor in a class, the garbage collector goes to the class before disposing of the object to ask whether you have a destructor, and if you have a destructor, then move the object to the next generation bucket.

In other words, even if the destructor itself is not used, it cleans up objects with destructors. Therefore, it will wait for the destructor to run, and then it will clean up the object. As a result, there are more objects in Generation 1 and Generation 2 than Generation 0.

(example) use destructor

Create a console application, then copy and paste the following code in the program class.

Note: if you write cleanup code in the destructor, you will end up creating more objects in generations 1 and 2, which means that you are not using memory correctly.

How to overcome the above problems?

This problem can be solved by using the so-called final disposal mode.

To achieve this, the class should implement the IDisposable interface and provide an implementation of the Dispose method. In the Dispose method, you need to write cleanup code for the unmanaged object, and finally you need to call GC. Suppresses the true method by passing true as an input value.

This method tells you to suppress any type of destructor and then clean up the object. For a better understanding, please look at the picture below.

Once you use the object, then you need to call the Dispose method so that the dual garbage collector loop does not occur, as shown below.

The complete code is as follows:

This is the end of the article on "how to use the .NET garbage Collector". Thank you for reading! I believe you all have a certain understanding of the knowledge of "how to use the .NET garbage collector". If you want to learn more, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.