C# IDisposable pattern and throwing ObjectDisposedException

A question for you all. In my company, we are developing an application that runs inside Microsoft’s MVC framework. The controller classes that we are implementing inherit from the MVC base class Controller. Example: ``` public class MyController: Controller { protected bool IsDisposed { get; set; } … various methods… } ``` The discussion we are having in the team centers around the Dispose() pattern. Essentially, this involves implementing the IDisposable interface, preferably according to the Microsoft-endorsed pattern. See for example this link: http://msdn.microsoft.com/en-us/library/fs2xkftw%28v=vs.110%29.aspx Interestingly, our controller classes do not own any resources, either managed or managed. As a result, the implementation of Dispose(bool) is greatly simplified: ``` protected override void Dispose(bool disposing) { IsDisposed = true; base.Dispose(disposing); } ``` There is some disagreement about the use (or need) of the `IsDisposed` property, that is used in the following method: ``` protected void ThrowIfDisposed() { if (IsDisposed) throw new ObjectDisposedException(“MyController”); } ``` This method is then called at the beginning of every method that does "real" work. The thinking here is that a disposed object should not be used again, hence it should throw the ObjectDisposedException. The other opinion is that, since `Dispose(bool)` does “nothing” (other than setting the `IsDisposed` property and calling `Dispose(bool)` on the base class), the “disposed” object is not really in a state that is unusable, so there is no reason to throw. Therefore, there is no reason to even implement `Dispose(bool)`. An argument against this is that MyController should throw when it is disposed and one of its methods is called, so that its behaviour does not change should in future versions managed and/or unmanaged resources be added. The argument against this last point is that MyController should never add any resources in future versions, but rather it should be derived from should the need to add resources occur in the future. An additional question is: why doesn’t the (library) class Controller implement `ThrowIfDisposed()` or something similar? So, summarizing, faction one wants to implement `Dispose(bool)` and `ThrowIfDisposed()` as shown above, faction two thinks they are unnecessary and wants to do away with them. I see merits in both viewpoints, cannot really make up my mind. Opinions?