Lazy resolution of dependency injection

Question

I have .net classes I am using unity as IOC for resolving our dependencies. It tries to load all the dependencies at the beginning. Is there a way (setting) in Unity which allows to load a dependency at runtime?

Answer 1

There's even better solution - native support for Lazy<T> and IEnumerable<Lazy<T>> in the Unity 2.0. Check it out here.

Answer 2

I have blogged some code here to allow passing 'lazy' dependencies into your classes. It allows you to replace:

class MyClass(IDependency dependency)

with

class MyClass(ILazy<IDependency> lazyDependency)

This gives you the option of delaying the actual creation of the dependency until you need to use it. Call lazyDependency.Resolve() when you need it.

Here's the implementation of ILazy:

public interface ILazy<T>
{
    T Resolve();
    T Resolve(string namedInstance);
}

public class Lazy<T> : ILazy<T>
{
    IUnityContainer container;

    public Lazy(IUnityContainer container)
    {
        this.container = container;
    }

    public T Resolve()
    {
        return container.Resolve<T>();
    }

    public T Resolve(string namedInstance)
    {
        return container.Resolve<T>(namedInstance);
    }
}

you will need to register it in your container to be able to use it:

container.RegisterType(typeof(ILazy<>),typeof(Lazy<>));

Answer 3

Unity should be lazily constructing instances, I believe. Do you mean that it is loading the assemblies containing the other dependencies? If that's the case, you might want to take a look at MEF - it's designed specifically for modular applications.