out >> m_Conscientia; » IDisposable

Should Dispose throw exceptions?

Alex Peck — Wed, 18 Nov 2009 23:47:51 +0000

The Framework Design Guidelines suggest that you should avoid throwing an exception from Dispose. This page has a better quote:

Avoid throwing an exception from within Dispose except under critical situations where the containing process has been corrupted (leaks, inconsistent shared state, etc.).

I can think of two good reasons to avoid throwing (depending on your use case they may or may not represent the desired behaviour):

If there is an unhandled exception in the finaliser thread, under .NET 2.0 and above, the process terminates. Yikes. As MSDN states, IDisposable classes should call Dispose from the finaliser to be sure Dispose is always called.
Exception masking: If dispose is triggered by a using block after an exception is thrown inside the block, then Dispose throws, you will get the exception from dispose, not the original.

Rogue Dispose methods pop up in the .NET framework (e.g. in WCF), and in other libraries. If you have to contend with some dangerous disposal, Marc Gravell has a safe IDisposable wrapper template/extension method pattern. This could easily be modified to do some logging rather than silently swallowing.

.NET Framework Interfaces

Alex Peck — Wed, 01 Jul 2009 22:30:33 +0000

Interfaces define a common set of functionality which all classes that implement the interface must provide. For the purposes of the training course, six framework interfaces are relevant:

IDisposable	Free up (primarily unmanaged) resources which a class instance is responsible for. This article describes how to correctly implement IDisposable.
IConvertable	Convert the implementer’s value into a CLR type
ICloneable	Create a new instance of a class based on an existing one. This is now deprecated because it was unclear whether it meant deep or shallow copy, as suggested by Eric Lippert here.
IComparable	Implemented by types which can be sorted based on a single method, CompareTo. This determines whether objects are greater or less than each other.
IEquatable	Determine whether implementing class instances are equal
IFormattable	Convert the implementer’s value into a formatted string. Useful in conjunction with System.Globalization.CultureInfo

When dependency injection meets IDisposable

Alex Peck — Sun, 21 Jun 2009 21:50:58 +0000

What follows is a solution which should really have been obvious to me the first time I faced the problem: how do you decouple logic and instantiation of collaborating objects when faced with an IDisposable class? Consider this:

public class NiceClass
{
    private DependentClass injectedDependency;
 
    public NiceClass(DependentClass injectedDependency)
    {
        this.injectedDependency = injectedDependency;
    }
 
    public void CoupledMethod()
    {
        using (IFace c = new Face(injectedDependency))
        {
            // do something with c
        }
    }
}

We can see that injectedDependency is not coupled, but what about the local instance of Face in CoupledMethod? To decouple it use a delegate to return the IFace instance instead of calling new directly. If the coupling had been to a concrete type (Face), we could refactor to an abstract type (IFace) or wrapper first.

public class NiceClass
{
    public delegate IFace IFaceCreatorDelegate(DependentClass injectedDependency);
 
    private DependentClass injectedDependency;
    private IFaceCreatorDelegate iFaceCreator;
 
    public NiceClass(DependentClass injectedDependency, IFaceCreatorDelegate iFaceCreator)
    {
        this.injectedDependency = injectedDependency;
        this.iFaceCreator = iFaceCreator;
    }
 
    public void CoupledMethod()
    {
        using (IFace c = iFaceCreator(injectedDependency))
        {
            // do something with c
        }
    }
}

This is an additional three lines of code, which arguably makes the control flow harder to read statically. It does, however, improve testability. I think of this as equivalent to the classic tradeoff between abstract and concrete parameters.

Instantiating NiceClass is not too arduous either with a lambda expression (although it is still a little verbose).

NiceClass nice = new NiceClass(
   dependency, 
   (DependentClass d) => new Face(d));