Caliburn.micro与团结

Question

At the moment I'm learning more about caliburn.micro and it is amazing.

In my small demo project with some navigation there is MEF and the EventAggregator.

As I want to use caliburn.micro in a project where unity is already in use, I want to use Unity for DI.

How can I set up the bootstrapper to use Unity?

Any good tutorials besides the MindScape tutorial and those on the codeplex page are very welcome. (except that I did not see the right one handling this case)

Answer 1

There are 4 methods you have to override in bootstrapper to wire the IoC container (when using Boostrapper<T> ):

1. Configure()

   That's usually where you initialize the container and register all dependencies.

2. GetInstance(string, Type)

   Retrieval of the object by type and key - as far as I can tell it's usually used by framework to retrieve eg view models, regular dependencies. So here your container has to somehow get an instance based on a string and/or Type (usually type, string is used when you wire the model to the view using view-first binding). Usually containers have similar methods built in, which work out of the box or need just a little adjustment.

3. GetAllInstances(Type)

   Retrieval of collection of objects (by type only) - again, as far as I can tell from experience, this one is usually used by Caliburn.Micro for views.

4. BuildUp(object)

   A method where you can do property injection on an object.

If you're interested, I have a sample which uses SimpleInjector (or Autofac), unfortunately I have no experience with Unity.

[EDIT]

Sample time! This one is using SimpleInjector.

public class MainViewModel
{
//...
}

public class ApplicationBootstrapper : Bootstrapper<MainViewModel>
{
    private Container container;

    protected override void Configure()
    {
        container = new Container();

        container.Register<IWindowManager, WindowManager>();
      //for Unity, that would probably be something like:
      //container.RegisterType<IWindowManager, WindowManager>();
        container.RegisterSingle<IEventAggregator, EventAggregator>();

        container.Verify();
    }

    protected override object GetInstance(string key, Type service)
    {
        // Now, for example, you can't resolve dependency by key in SimpleInjector, so you have to
        // create the type out of the string (if the 'service' parameter is missing)
        var serviceType = service;
        if(serviceType == null)
        {
            var typeName = Assembly.GetExecutingAssembly().DefinedTypes.Where(x => x.Name == key).Select(x => x.FullName).FirstOrDefault();
            if(typeName == null)
                throw new InvalidOperationException("No matching type found");

            serviceType = Type.GetType(typeName);
        }

        return container.GetInstance(serviceType);
        //Unity: container.Resolve(serviceType) or Resolve(serviceType, name)...?

    }

    protected override IEnumerable<object> GetAllInstances(Type service)
    {
        return container.GetAllInstances(service);
        //Unity: No idea here.
    }

    protected override void BuildUp(object instance)
    {
        container.InjectProperties(instance);
        //Unity: No idea here.
    }
}

Answer 2

I found the Wiki for CM very helpful, and coming from a Unity/CSL background the Bootstrapper<TRootModel> method names and signatures were intuitive.

I wanted to share my own Class UnityBootstrapper<TRootModel> which utilizes Unity 3, it's small, clean and does what you would expect.

/// <summary>
/// <para>Unity Bootstrapper for Caliburn.Micro</para>
/// <para>You can subclass this just as you would Caliburn's Bootstrapper</para>
/// <para>http://caliburnmicro.codeplex.com/wikipage?title=Customizing%20The%20Bootstrapper</para>
/// </summary>
/// <typeparam name="TRootModel">Root ViewModel</typeparam>
public class UnityBootstrapper<TRootModel>
    : Bootstrapper<TRootModel>
    where TRootModel : class, new()
{
    protected UnityContainer Container
    {
        get { return _container; }
        set { _container = value; }
    }

    private UnityContainer _container = new UnityContainer();

    protected override void Configure()
    {
        if (!Container.IsRegistered<IWindowManager>())
        {
            Container.RegisterInstance<IWindowManager>(new WindowManager());
        }
        if (!Container.IsRegistered<IEventAggregator>())
        {
            Container.RegisterInstance<IEventAggregator>(new EventAggregator());
        }
        base.Configure();
    }

    protected override void BuildUp(object instance)
    {
        instance = Container.BuildUp(instance);
        base.BuildUp(instance);
    }

    protected override IEnumerable<object> GetAllInstances(Type type)
    {
        return Container.ResolveAll(type);
    }

    protected override object GetInstance(Type type, string name)
    {
        var result = default(object);
        if (name != null)
        {
            result = Container.Resolve(type, name);
        }
        else
        {
            result = Container.Resolve(type);
        }
        return result;
    }
}

You can instance this directly, providing a valid generic type parameter, or you can subclass and customize things such as Lifetime Managers:

public class AppBootstrapper
    : UnityBootstrapper<ViewModels.AppViewModel>
{
    protected override void Configure()
    {
        // register a 'singleton' instance of the app view model
        base.Container.RegisterInstance(
            new ViewModels.AppViewModel(), 
            new ContainerControlledLifetimeManager());

        // finish configuring for Caliburn
        base.Configure();
    }
}