This topic has not yet been rated - Rate this topic

CA2215: Dispose methods should call base class dispose

Visual Studio 2010

TypeName	DisposeMethodsShouldCallBaseClassDispose
CheckId	CA2215
Category	Microsoft.Usage
Breaking Change	Non Breaking

Cause

A type that implements System.IDisposable inherits from a type that also implements IDisposable. The Dispose method of the inheriting type does not call the Dispose method of the parent type.

Rule Description

If a type inherits from a disposable type, it must call the Dispose method of the base type from within its own Dispose method. Calling the base type method Dispose ensures that any resources created by the base type are released.

How to Fix Violations

To fix a violation of this rule, call base.Dispose in your Dispose method.

When to Suppress Warnings

It is safe to suppress a warning from this rule if the call to base.Dispose occurs at a deeper calling level than the rule checks.

Example

The following example shows a type TypeA that implements IDisposable.

Copy


using System;  

namespace UsageLibrary
{
    public class  TypeA :IDisposable
    {

        protected virtual void Dispose(bool disposing) 
        {
            if (disposing) 
            {
                // Dispose managed resources
            }

            // Free native resources
        }

        public void Dispose()
        {

                Dispose(true);

                GC.SuppressFinalize(this);

        }

        // Disposable types implement a finalizer.
        ~TypeA()
        {
            Dispose(false);
        }
    }
}

The following example shows a type TypeB that inherits from type TypeA and correctly calls its Dispose method.

Copy


Imports System

Namespace UsageLibrary

  Public Class TypeB
      Inherits TypeA

      Protected Overrides Sub Finalize()
          Try
              Dispose(False)
          Finally
              MyBase.Finalize()
          End Try
      End Sub

  End Class

End Namespace

Reference

Implementing Finalize and Dispose to Clean Up Unmanaged Resources

System.IDisposable

Did you find this helpful? Yes No

Not accurate

Not enough depth

Need more code examples

(1500 characters remaining)

Community Content Add

FAQ

Complete example in C#

taken from - http://msdn.microsoft.com/en-us/library/b1yfkh5e.aspx

// Design pattern for a base class.
public class Base: IDisposable
{
    private bool disposed = false;

    //Implement IDisposable.
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Free other state (managed objects).
            }
            // Free your own state (unmanaged objects).
            // Set large fields to null.
            disposed = true;
        }
    }

    // Use C# destructor syntax for finalization code.
    ~Base()
    {
        // Simply call Dispose(false).
        Dispose (false);
    }
}

// Design pattern for a derived class.
public class Derived: Base
{
    private bool disposed = false;

    protected override void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Release managed resources.
            }
            // Release unmanaged resources.
            // Set large fields to null.
           // Call Dispose on your base class.
            disposed = true;
        }
        base.Dispose(disposing);
    }
    // The derived class does not have a Finalize method
    // or a Dispose method without parameters because it inherits
    // them from the base class.
}

History

12/16/2010
akjoshi