title: IDisposable implementation in Abstract class hierarchy
body: <p>I am having following class hierarchy -</p>
  
  <pre><code>//Abstract Class1 in library1 (Can't modify this)
  public abstract class absClass1 : IDisposable
  {
      public abstract int AddTwoNumbers(int Num1, int Num2);
      // Some other overrides, abstract methods and concrete methods
  
      void Dispose()
      {
         // Standard Dispose impl.
      }
  }
  
  //Abstract Class2 in library2
  public abstract class absClass2 : absClass1
  {
      //Implementing AddTwoNumbers
      public override int AddTwoNumbers(int Num1, int Num2)
      {
         return Num1+Num2;
      }
  
      public abstract int MultiplyTwoNumbers(int Num1, int Num2);
  
      // Some other overrides, abstract methods and concrete methods
  
      protected override void Dispose(bool disposing)
      {
          if (!IsDisposed)
          {
              //Cleanup
          }
  
          base.Dispose(disposing);
      }
  }
  
  //Derived class from absClass2 in library3
  public sealed class absDerived1 : absClass2
  {
      //Implementing MultiplyTwoNumbers
      public override int MultiplyTwoNumbers(int Num1, int Num2)
      {
         return Num1*Num2;
      }
  
      // Some other overrides, abstract methods and concrete methods
  
      protected override void Dispose(bool disposing)
      {
          if (!IsDisposed)
          {
              // Cleanup
          }
  
          base.Dispose(disposing);
      }
  }
  
  //... Some more implementation of absClass2 like absDerived2 etc.
  //  can be there in other library4...
  </code></pre>
  
  <p>I want to dispose objects in both <code>absClass2</code> and <code>absDerived</code>, is there any problem in overriding Dispose(bool) in both these classes? Is there any problem with this design? How can this be improved? </p>