What should Dispose do - only cleanup the resources or perform some "business logic" as well?

Question

Considering the semantics of IDisposable, what should the Dispose do, other than cleaning the resources of course?

I saw that many classes use Dispose method to initiate shutdown processes and some other stuff, and not just doing the "resource cleanup" work. For example, if you have a thread inside the class, which needs to be shutdown, would you expect that calling Dispose gracefully shuts down this thread?

IMHO I would implement a Stop / Shutdown method on this object, and gracefully shutdown the thread there, while in the Dispose I would check when thread is still alive to simply call Abort on it (assassination style :) ).

The same example can be with timers, and all other resources which can have the some sort of termination process before finishing you work with that object.

Two examples of conflicting designs in .NET:

ServiceBase for windows services has OnStop as well as Dispose to override.
WebApp.Start from OWIN for self-hosting gives you back an IDisposable which I guess does the service shutdown somewhere in the Dispose process.

NPSF3000 · Answer 1 · 2014-02-15T13:42:43.517

To be difficult, I've used dispose only do business logic. For example:

public class UsingBase : IDisposable
{
    protected Action end;
    public UsingBase(Action start, Action end) { this.end = end; if (start != null) start(); }
    public void Dispose() { if (end != null) end(); }
    public void Cancel() { end = null; }
}

class HideCursor : UsingBase { public HideCursor() : base(() => Console.CursorVisible = false, () => Console.CursorVisible = true) { } }

public static void DisplayTitle(...)
{
    ...
    using (new HideCursor())
    {
       //Display the title
    }
    ...
}

And while some may conside this an abuse of the language, I got the idea from the ASP.net API.

@using (Html.BeginForm())
{
    ...
}

To get back to your question

For example, if you have a thread inside the class, which needs to be shutdown, would you expect that calling Dispose gracefully shuts down this thread?

I'd like it to when such makes sense - because I often use objects with using, letting it take care of it's own disposal. Of course, if you clearly document your logic, and have a clear reason to differentiate 'graceful stop' from 'dispose' then that could work.

Or in other words - I don't want to be doing this for no reason:

using (var blah = new Blah())
{
...
...
...
Blah.SpecialDispose();
}//Blah.Dispose();

Because it'll cause the exact problem that using is trying to stop - people forgetting to write the right wrapper code (e.g. try finally).

Edit:

In summary. Yes, business logic can be done Dispose. Yes, Dispose can handle things 'nicely'. Those are the main questions you posed. However, that does not necessarily negate the possible use case where Dispose is used as a 'last resort' and is more abrupt in it's actions. It sounds like you are confident in your use-case, in which case go ahead. If you still want feedback I suggest posting a more specific question related to your actual use case.

Yes you do have a point. Sometimes, for some usages, using makes a nice "abuse". However, I can also say that I am looking at this problem from the point where the "shutdown" is really part of the object definition / identity / known to everybody, and not something that could be forgotten. — Denis Biondic, Feb 15 '14 at 11:24
You know of the different ways of using dispose and using, you've looked at alternate use-cases and you still believe your use is valid and logical? Unless someone posts something to change the above, it seems like you're making an informed decision - who am I to argue? — NPSF3000, Feb 15 '14 at 13:36

score 1 · Accepted Answer · answered Feb 17 '14 at 20:34

Rather than thinking in terms of an IDisposable contract, it's more helpful to think of IDisposable as being part of a general Object contract which says that objects should not require any form of notice other than IDisposable.Dispose before they are abandoned (objects which don't implement IDisposable should not require any sort of notice at all). The Dispose method should do anything and everything that needs to be done before an object can be safely abandoned.

The only aspect of this which is problematical is that exceptions may occur while performing cleanup, and there's no way for Dispose to know what it should do in such case. If Dispose is called during normal (non-exceptional) program execution, it should throw an exception if cleanup fails. If it is called while unwinding the stack from from an exception, however, any exception it might throw would generally destroy all evidence of the earlier exception (thus is would often be better for it to fail silently than throw an exception). Unfortunately, there's no way via which Dispose can tell which situation applies, and thus no way for it to consistently do the right thing in case of cleanup failure.

What should Dispose do - only cleanup the resources or perform some "business logic" as well?

2 Answers2