Disposable types should declare finalizer

A type that implements System.IDisposable, and has fields that suggest the use of unmanaged resources, does not implement a finalizer as described by System.Object.Finalize.

A violation of this rule is reported if the disposable type contains fields of the following types:

• System.IntPtr

• System.UIntPtr

• System.Runtime.InteropServices.HandleRef

To fix a violation of this rule, implement a finalizer that calls your Dispose method.

It is safe to exclude a warning from this rule if the type does not implement IDisposable for the purpose of releasing unmanaged resources.

The following example shows a type that violates this rule.

using System;  
using System.Runtime.InteropServices;

namespace UsageLibrary
{
    public class  DisposeMissingFinalize :IDisposable
    {
        private bool disposed = false;
        private IntPtr unmanagedResource;
        
        [DllImport("native.dll")]
        private static extern IntPtr AllocateUnmanagedResource();
        
        [DllImport("native.dll")]
        private static extern void FreeUnmanagedResource(IntPtr p);
        
        DisposeMissingFinalize()
        {
            unmanagedResource = AllocateUnmanagedResource();
        }
        
        protected virtual void Dispose(bool disposing) 
        {
            if (!disposed) 
            {
                // Dispose of resources held by this instance.
                FreeUnmanagedResource(unmanagedResource);
                disposed = true;
   
                // Suppress finalization of this disposed instance.
                if (disposing)
                {
                    GC.SuppressFinalize(this);
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
        }

        // Disposable types with unmanaged resources implement a finalizer.
        // Uncomment the following code to satisfy rule:
        //  DisposableTypesShouldDeclareFinalizer
        // ~TypeA()
        // {
        //     Dispose(false);
        // }
    }
}

Call GC.KeepAlive when using native resources

Dispose methods should call SuppressFinalize

Types that own native resources should be disposable

Implementing Finalize and Dispose to Clean Up Unmanaged Resources
System.IDisposable
System.IntPtr
System.Runtime.InteropServices.HandleRef
System.UIntPtr
System.Object.Finalize