.NET Dependency Injection Frameworks

As Martin Fowler mentions it in his article, the basic idea of the Dependency Injection (DI) is to have a separate object, that populates a field in another class with an appropriate implementation of a specific interface. DI can be applied in three different ways: Constructor Injection, Setter Injection, and Interface Injection. A container I’ve used on several projects is the Pico Container.

Applied to the figure below, we will take Martin’s idea to say that: The basic idea of the Dependency Injection is to have a separate object, an assembler, that populates a field in the lister class with an appropriate implementation for the finder interface, resulting in a dependency diagram.

Screen Shot 2016-05-04 at 2.56.43 PM

Let’s go over the 3 types of DI.

Constructor Injection: A container like Pico uses a constructor to decide how to inject an implementation into a class.

Setter Injection: We define in a specific class, a setting method for a service we want to inject in a class. Spring.NET makes a big use of this method.

Interface Injection: This technique defines and uses interfaces for the injection. Avalon users enjoy it.

public interface InjectFinder {
    void injectFinder(MovieFinder finder);
}

This interface would be defined by whoever provides the MovieFinder interface. It needs to be implemented by any class that wants to use a finder, such as the lister.

class MovieLister implements InjectFinder

  public void injectFinder(MovieFinder finder) {
      this.finder = finder;
  }

Coming back to DI frameworks, I have found the following on StackOverflow and it does a pretty good description of those. The question was: Which .NET DI framework are worth looking into?
And here is the answer.

It depends on what you are looking for, as they each have their pros and cons.

  1. Spring.NET is the most mature as it comes out of Spring from the Java world. Spring has a very rich set of framework libraries that extend it to support Web, Windows, etc.
  2. Castle Windsor is one of the most widely used in the .NET platform and has the largest ecosystem, is highly configurable / extensible, has custom lifetime management, AOP support, has inherent NHibernate support and is an all around awesome container. Windsor is part of an entire stack which includes Monorail, Active Record, etc. NHibernate itself builds on top of Windsor.
  3. Structure Map has very rich and fine grained configuration through an internal DSL.
  4. Autofac is an IoC container of the new age with all of it’s inherent functional programming support. It also takes a different approach on managing lifetime than the others. Autofac is still very new, but it pushes the bar on what is possible with IoC.
  5. Ninject I have heard is more bare bones with a less is more approach (heard not experienced).
  6. The biggest discriminator of Unity is: it’s from and supported by Microsoft (p&p). Unity has very good performance, and great documentation. It is also highly configurable. It doesn’t have all the bells and whistles of say Castle / Structure Map.

So in summary, it really depends on what is important to you. I would agree with others on going and evaluating and seeing which one fits. The nice thing is you have a nice selection of donuts rather than just having to have a jelly one.

 


Sources
http://stackoverflow.com/questions/21288/which-net-dependency-injection-frameworks-are-worth-looking-into
http://www.martinfowler.com/articles/injection.html

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: