Should I use Microsoft.Practicies.Unity.IUnityContainer in my MVVM application?

Question

Jason Dolinger in his video located here (hot available right now) www.lab49.com/files/videos/Jason%20Dolinger%20MVVM.wmv (from 0.59 to 1.04) uses such code:

public partial App: Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
        IUnityContainer container = new UnityContainer();
        RandomQuoteSource source = new RandomQuoteSource();
        container.RegisterInstance<IQuoteSource>(source);

        WatchList window = container.Resolve<WatchList>();
        window.Show();
    }
}

He uses class IUnityContainer which I can not found. As I understand here we just create a window (so container.Resolve call can be replaced with new WatchList(..., also somehow we associate RandomQouteSource as an implementation for IQouteSource, however I don't have clear understanding how this should be used later.

The questions are:

• how do you create main Windows in your MVVM application, do you also use IUnityContainer for that?
• is it good technics in general? is it well-known? is it default way to do these things? what alternativies do I have?
• where can I find Microsoft.Practicies.Unity.dll?

Answer 1

Should you?

That's up to you. It can be complicated. If you use it correctly, it can be worth it, both for your code, and for your knowledge of how your code works.

You will be able to identify the parts of your application that should only touch other parts at arms length. You will be more free to make changes to your code without impacting other portions of your code. You will also have an easier time creating unit tests that use mock objects, but that's just a side benefit.

You'll have to read some articles on this topics and see if it makes sense to you.

(to be fair, it really isn't complicated - it just seems that way while you're learning it, or while you're trying to explain it to someone who is new to the concepts)

Unity and Dependency Injection

IUnityContainer is part of Unity, which is a Dependency Injection container library.

It can be coupled with the PRISM framework for use in WPF/Silverlight.

Dependency Injection has a lot of rules you'll want to follow to get the maximum benefit. I don't see an easy or effective "getting started" guide on Unity's site, and Mark Seemann's book on Dependency Injection in .Net isn't free.

So instead I suggest you check out an intro tutorial on Dependency Injection on a site that has a good tutorial:

• https://github.com/ninject/ninject/wiki/Getting-Started

This is not the Unity framework, so the code won't directly compile...

...but it should teach you the basics of what Dependency Injection is, and why you'd want to use it. Then you should be able to follow the sample code and videos on the Unity page.

If you skip these steps, you're going to get confused very quickly, and will probably shoot yourself in the foot at least a few dozen times.

Creating Windows

You don't use the container except in that one function. Use it anywhere else, and you're not using the DI container correctly. You'll just use the container to register your views, view models, and models, resolve the main window you previously registered, and dispose the container when you're done.

This process is called the "Three Calls Pattern". Unfortunately I don't have any generic examples for Unity, but here is an article on the three calls pattern for yet-another DI container library.

You might also see this mentioned in that Ninject tutorial that I linked above.

Answer 2

It's a well known technic called Dependency Injection.

An alternativ is to create the needed dependency by hand.

You can download the unity assemblies at patterns & practices - Unity from codeplex.

Take a look at codeproject article for a tutorial.

I havent worked with wpf but i would go the same way to minimize the dependencies and get a better testability.

Edit

Here is another example from codeplex.

But read this article from here stack first, cause it seems to be a pain

Answer 3

using dependency injection is a good practice in general. it lets your classes worry about their own concerns and leave the framework to worry about managing dependencies. this leads to more focused, more maintainable, and more testable code in your classes. unity is just one of many such frameworks and it could be argued there are others that are better, such as structuremap and castle windsor. using a container basically means that in one place you set up a registry from which you resolve your classes with their dependencies and you classes specify in their constructor or with public properties those things on which they depend. if you resolve a class from the container, it will automatically resolve its dependencies according to the type of the dependency based on how that type is registered with a container.

the easiest way to include unity in your project is to use nuget. just issue: install-package unity. you can also download binaries and source and get a lot more information at the codeplex project for unity: http://unity.codeplex.com/.

Answer 4

One suggestion is Ninject - a lightweight, easy to use DI-tool.