Tuesday, March 23, 2010
I’m feeling a bit guilty about some code I wrote:
using (new OperationTimer("MyOperation", this))
// ... complete operation
This innocent looking C# snippet is hiding a tricky secret - the
using statement is being misused (no pun intended). The documentation defines the intended usage clearly:
- using Statement
- Defines a scope, outside of which an object or objects will be disposed.
The problem? The notion of “object disposal” is being hijacked! In your garden variety
IDisposable implementation, you’d be dealing with an external resource that needs to be released before the object can be removed from memory. Instead, I’m using it to time a block of code like so:
class OperationTimer : IDisposable
private readonly string _operationName;
private readonly ITimable _obj;
private readonly Stopwatch _stopwatch;
public OperationTimer(string operationName, ITimable obj)
_operationName = operationName;
_obj = obj;
_stopwatch = new Stopwatch();
public void Dispose()
The constructor starts a timer and the
Dispose() method stops it and reports the elapsed time. (aside: if you’re interested in how I’m using the timer, check out my previous article Simplified Performance Counters) There are certainly other ways to accomplish this same behavior, but they lack the elegance of a neatly scoped code block. It’s arguably an acceptable way to repurpose the language. In fact, the ASP.NET MVC authors saw fit to use it in a similar fashion with the BeginForm helper. The only “resource” it disposes of is to render a closing
My question is: When does repurposing language constructs turn from “acceptable language use” to a “dirty trick”, or worse, “illegible line noise”?
It seems like a slippery slope. One instance that I don’t care for is controlling execution flow by-way-of logical operator precedence in most C-like languages:
expression1 && expression2 || expression3
Which is equivalent to:
This takes advantage of the order of evaluation in a logical statement – it is assumed (correctly) that
expression2 will never be evaluated if
expression1 is evaluated as false, and instead,
expression3 will get to run. Likewise, if the first two evaluate to true, the truth value is known for the statement and
expression3 is never evaluated. This is clearly not the intended usage which the language designers had in mind, but it works, and it saves any keywords from being written.
Some truly beautiful code has been written by way of hijacking the language. For instance, here’s a program that will calculate the value of pi using an ascii circle. Truly neat - but also completely useless from a software development standpoint.
What do you think? Should I just get over my guilt about repurposing
IDisposable? Or, should I be true to the original intent of the language and find another way?