Question

I have some questions about DI containers (Unity in particular) and how they actually aid in DI.

I believe I understand IoC/DI and have been using constructor based DI for some years. Usually with my use of DI it involved simply having a constructor on my class, say MyClassX that takes an interface as an argument say IDataService and then using the new operator to create an instance of an IDataService implementing class and pass it into MyClassX’s constructor. This way MyClassX doesn’t need to know the exact type of the IDataService it is using decoupling it from a specific type. Now correct me if I am wrong, but that’s what I understand DI to be…though it does not have to be constructor based.

Now I have seen a stack of examples of Unity on the net, but I am finding it difficult to not only understand everything it does (it seems like a magic object factory to me) but also how it exactly aids in DI as I understand it. To me Unity seems more like a Factory implementation (or a Mock framework?) rather than anything to do specifically with DI. I think I have really missed something though and am waiting for an “ah ha” moment. I have done alot of Googling but examples don’t help… I need an theoretical explanation.

Can someone explain to me what Unity is exactly for…the broad points of what it does and how it is related to DI as I understand it.

Answer 1

Your understanding of basic Dependency Injection is correct. Constructor injection is the most common pattern.

Some other DI Unity does:

1. Lifetime management – instance creation can be singleton, one per
   thread, and other advanced models.
2. Handles dependency graphs – request a root object and Unity creates all its dependency’s
   dependencies.
3. Enables method and property injection – requires a
   Unity attribute in your business code (which I prefer to avoid)
4. Service locator pattern – generally considered an anti-pattern

1 and 2 are nice when you need them. I think #3 and #4 are to be avoided when possible because it adds dependencies in your code to your Unity container.

The big bang that you are missing is Aspect Oriented Programing enabled by Interception with Unity. This allows the implementation of cross cutting concerns. Logging is the classic example. If you want more, start reading all the Enterprise Library Call Handlers for exception handling, validation, etc. or just start searching the web for AOP.

When you combine constructor injection of dependencies with external implementation of cross cutting concerns, you can get very close to business objects that only contain business logic. In a large Enterprise development team, that’s a very big bang.