The Wait Class
Back when I did most of my coding with C++ I really liked the simplicity and compactness of using class constructors and destructors to do simple tasks such as setting a wait or busy cursor. For example, consider the code in Figure 1. It is a compact and simple API that is very easy to use and hard to use incorrectly.
void SomeClass::SomeMethod()
{
//at this point the constructor would run and set our
//cursor to busy.
CWaitCursor cur;
//do some work here
}//at this point the destructor would run setting our
//cursor back to its original state. |
Figure 1
Today however I use C# as my primary development language and wanted to keep with what I knew worked in the C++ world so well. Since the CLR does not run the destructors (or finalizers) on its objects at predictable times there needed to be some modification to how I would implement and use the C# version of CWaitCursor (Figure 2).
internal class Wait : IDisposable
{
Cursor _savedCursor;
Form _form;
public Wait(Form form)
{
if(form == null)
throw new ArgumentException("form");
_form = form;
_savedCursor = _form.Cursor;
_form.Cursor = Cursors.WaitCursor;
}
public void Dispose()
{
_form.Cursor = _savedCursor;
}
} |
Figure 2
Now to use my Wait class all I need to do is instantiate a new instance within one of my Forms, pass a reference to that form and use the "using" construct offered by the C# language.
public void SomeMethodOfAForm()
{
using(new Wait(this))
{
//do some work here
}
} |
Figure 3
Ok at this point I should say I don't want to get into any debate with anyone over which language is better, which method is more preferred, etc... I will also point out before I am sure someone else will that this cannot be used with ASP.NET, ok you got me!
Correction: Rico was kind enough to point out that my Wait class was not finalizable so I did not need to SuppressFinalize on it.
