How to use dependency injection in enterprise projects

architecture, c#, dependency-injection, inversion-of-control

Solution

First of all, Dependency Injection is a design pattern that does not require a container. The DI pattern states:

Dependency injection is a software design pattern that allows a choice of component to be made at run-time rather than compile time

Take for example Guice (java dependency injection framework), in Java Guice is a DI framework but it is not a container itself.

Most of the DI tools in .Net are actually containers, so you need to populate the container in order to be able to inject the dependency

I do not like the idea to have to register every component every time in a container, I simply hate that. There are several tools that help you auto register components based on conventions, I do not use Unity, but I can point you for example to Ninject or AutoFac

I am actually writing a small utility to auto register components based on conventions using practically any DI tool, it is still in dev phase

About your questions:

Should there be a "general container" that can be used for bootstrapping, accessible as a Singleton?

The answer is yes, (there's a tool to abstract the DI tool used, it is called ServiceLocator) that's how DI tools work, there is a static container available to the application, however, it is not recommended to use it inside the domain objects to create instances, that's considered an anti-pattern

BTW I have found this tool really useful to register components at runtime:

http://bootstrapper.codeplex.com/

Should a container be passed around, where all instances can RegisterInstance?

No. that would violate the law of Demeter. If you decide to use a container is better to register the components when the application starts

How can the container be made accessible when needed

Well using the Common Service Locator you could use it anywhere in your application, but like I said, it is not recommended to use it inside the domain objects to create the required instances, instead, inject the objects in the constructor of the object and let the DI tool to automatically inject the correct instance.

Now based on this:

Constructor injection seems false, controverse of being the standard way, you have to pass down interfaces from a component level to the very down where it is used right on startup, or a reference is hold ending up in a "know where you live" antipattern

Makes me think that you are not writing unit tests heavily for your application which is bad. So my suggestion is, before choosing between which DI tool you are going to use, or before taking all the answers you get to this question into consideration, refer to the following links which are focus on one thing: Write clean testable code, this is by far the best source you could get to answer yourself your own question

Clean Code talks:

http://www.youtube.com/watch?v=wEhu57pih5w&feature=player_embedded

http://www.youtube.com/watch?v=RlfLCWKxHJ0&feature=player_embedded

Articles

http://misko.hevery.com/2010/05/26/do-it-yourself-dependency-injection/

http://misko.hevery.com/code-reviewers-guide/

Previous link in PDF http://misko.hevery.com/attachments/Guide-Writing%20Testable%20Code.pdf

The following links are super highly recommended

http://misko.hevery.com/2008/09/30/to-new-or-not-to-new/

http://www.loosecouplings.com/2011/01/how-to-write-testable-code-overview.html

Problem

Original source