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 a class you need to instantiate inline, such as 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
{
    private DependentClass injectedDependency;
    private Func<DependentClass, IFace> faceFactoryMethod;
 
    public NiceClass(
        DependentClass injectedDependency, 
        Func<DependentClass, IFace> faceFactoryMethod)
    {
        this.injectedDependency = injectedDependency;
        this.faceFactoryMethod = faceFactoryMethod;
    }
 
    public void CoupledMethod()
    {
        using (IFace c = this.faceFactoryMethod(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, d => new Face(d));

Dependency Injection & Testability

Alex Peck — Wed, 17 Jun 2009 19:01:06 +0000

When objects have no (or few) collaborators it’s relatively easy to get high unit test code coverage. As the number and complexity of collaborators increases, so too does the difficulty in obtaining decent coverage. This talk illustrates why dependency injection principles improve the testability of your code, and ease mock/stub based unit testing.

out >> m_Conscientia; » Dependency Injection

When dependency injection meets IDisposable

Dependency Injection & Testability