Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of how C # implements the IDisposable interface to release unmanaged resources, the content is detailed and easy to understand, the operation is simple and fast, and has a certain reference value. I believe everyone will gain something after reading this article on how to implement the IDisposable interface to release unmanaged resources. Let's take a look.

When another class that implements IDisposable is used as a member attribute in a class, it is necessary for the class to implement the IDisposable interface to ensure that unmanaged resources are actually released in the appropriate way. How to implement this interface correctly? Of course, this is just one of the cases where you need to implement the IDisposable interface.

Complete example

The Foo class of the example contains a _ stream member of type Stream, so you need to implement the IDisposable pattern for the Foo class

Public class Foo: IDisposable {private bool _ disposed; private readonly Stream? _ stream; public Foo () {_ stream = File.Create ("1.txt", 2048);} ~ Foo () {CleanupUnmanagedResources ();} private void CleanupUnmanagedResources () {if (_ disposed) return; / / release unmanaged resources _ stream?.Dispose (); _ disposed = true } public void Dispose () {CleanupUnmanagedResources (); GC.SuppressFinalize (this);}} Why should the Foo destructor be implemented

Because of the weakness of human nature.

Haha, in fact, because we may forget to call its Dispose method manually when using Foo, if there is no destructor at this time, it may lead to the tragedy that resources will never be released and eventually lead to memory leaks.

Of course, releasing unmanaged resources in destructors may incur additional overhead on GC, so it's best to still use using blocks to ensure that Dispose methods are called in time, and destructors are used here just to prevent accidents. As for why releasing unmanaged resources in a destructor leads to additional GC overhead, it involves the GC recycling process. GC will not immediately recycle a class that contains a destructor, but will be marked by GC as the next generation, so that the class marked as the next generation will be really recycled only when GC decides to recycle the next generation of garbage objects. This will lead to additional memory and performance overhead.

Why to call GC.SuppressFinalize in Dispose method

The GC.SuppressFinalize method can tell GC that there is no need to call this class's destructor (Finalizers).

Because the Foo.CleanupUnmanagedResources method is called in the destructor of the Foo class, when GC recycles such calls to such destructors, it may result in two calls to Foo.CleanupUnmanagedResources (the first in the Dispose method) resulting in additional overhead

So when we manually call Foo.Dispose (through using syntax sugar), we need to tell GC, "you don't have to call my destructor when you recycle me. I have already released the resources that should be released." the code is GC.SuppressFinalize.

This is the end of the article on "how to implement the IDisposable interface to release unmanaged resources in C#". Thank you for reading! I believe you all have a certain understanding of the knowledge of "how to implement IDisposable interface to release unmanaged resources". 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.