Disposable types should declare finalizer

TypeName	DisposableTypesShouldDeclareFinalizer
CheckId	CA2216
Category	Microsoft.Usage
Breaking Change	NonBreaking

Cause

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.

Rule Description

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

How to Fix Violations

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

When to Exclude Warnings

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

Example

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);
        // }
    }
}

Related Rules

Call GC.KeepAlive when using native resources

Dispose methods should call SuppressFinalize

Types that own native resources should be disposable

See Also

Reference

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