At the risk of stepping into holy war territory, What are the strengths and weaknesses of these popular DI/IoC frameworks, and could one easily be considered the best? ..:

* Ninject
* Unity 
* Castle.Windsor
* Autofac
* StructureMap 

Are there any other DI/IoC Frameworks for C# that I haven&#39;t listed here?

In context of my use case, I&#39;m building a client WPF app, and a WCF/SQL services infrastructure, ease of use (especially in terms of clear and concise syntax), consistent documentation, good community support and performance are all important factors in my choice.

## Update:

The resources and duplicate questions cited appear to be out of date, can someone with knowledge of all these frameworks come forward and provide some real insight?
 
I realise that most opinion on this subject is likely to be biased, but I am hoping that someone has taken the time to study all these frameworks and have at least a generally objective comparison.

I am quite willing to make my own investigations if this hasn&#39;t been done before, but I assumed this was something at least a few people had done already.

## Second Update:

If you do have experience with more than one DI/IoC container, please rank and summarise the pros and cons of those, thank you. This isn&#39;t an exercise in discovering all the obscure little containers that people have made, I&#39;m looking for comparisons between the popular (and active) frameworks.


How do the major C# DI/IoC frameworks compare?

I have a test class with a constructor that needs an IService.

&lt;!-- language: lang-c# --&gt;

    public class ConsumerTests
    {
        private readonly IService _service;
        public ConsumerTests(IService servie)
        {
          _service = service;
        }
      
        [Fact]
        public void Should_()
        {
           //use _service
        }
    }

I want to **plugin my DI container of choice** to build the **test class**.

Is this possible with **xUnit**?

Is it possible to use Dependency Injection with xUnit?

I would like to be able to inject a generic implementation of a generic interface using Guice.

    public interface Repository&lt;T&gt; {
      void save(T item);
      T get(int id);
    }
    
    public MyRepository&lt;T&gt; implements Repository&lt;T&gt; {
      @Override
      public void save(T item) {
        // do saving
        return item;
      }
      @Override
      public T get(int id) {
        // get item and return
      }
    }

In C# using Castle.Windsor, I&#39;d be able [to do](http://using.castleproject.org/display/IoC/Fluent+Registration+API):

    Component.For(typeof(Repository&lt;&gt;)).ImplementedBy(typeof(MyRepository&lt;&gt;))

but I don&#39;t think the equivalent exists in Guice.  I know I can use `TypeLiteral` in Guice to register individual implementations, but is there any way to register them all at once like in Windsor?

**Edit:**

Here&#39;s an example of usage:

    Injector injector = Guice.createInjector(new MyModule());
    Repository&lt;Class1&gt; repo1 = injector.getInstance(new Key&lt;Repository&lt;Class1&gt;&gt;() {});
    Repository&lt;Class2&gt; repo2 = injector.getInstance(new Key&lt;Repository&lt;Class2&gt;&gt;() {});

Although the more likely usage would be injection into another class:

    public class ClassThatUsesRepository {
      private Repository&lt;Class1&gt; repository;
    
      @Inject
      public ClassThatUsesRepository(Repository&lt;Class1&gt; repository) {
        this.repository = repository;
      }
    }


Inject Generic Implementation using Guice

In a follow up to [Krzysztof’s statement][1] that [Windsor][2] does a lot more than other IoC’s, I wanted to understand how these IoC’s stack up against each other and the benefits/additional facilities that castle Windsor provides.  

Are there any comparisons? Can someone help me understand the additional features that Castle Windsor provides over other IoC’s   


  [1]: https://stackoverflow.com/questions/388355/castle-windsor-are-there-any-downsides/397461#397461
  [2]: http://www.castleproject.org/container/index.html

Comparing Castle Windsor, Unity and StructureMap

I have a MVC 3 web application, where I am using the Entity Framework for the data access. Furthermore, I have made a simple use of the repository pattern, where e.g. all Product related stuff is handled in the &quot;ProductRepository&quot; and all User related stuff is handled in the &quot;UserRepository&quot;. 

Thus, I am using the UNITY container, to make a singleton instance of the DataContext, which I inject into each of the repositories. A quick search on Google, and everyone recommends you to NOT use a singleton instance of the DataContext, as it might give you some memory leaks in the future. 

So, inspired by this post, making a singleton instance of the DataContext for each web request is the answer (please correct me if I am wrong!)

http://blogs.microsoft.co.il/blogs/gilf/archive/2010/05/18/how-to-manage-objectcontext-per-request-in-asp-net.aspx


However, UNITY does not support the &quot;Per-web-request&quot; lifetime manager. But, it is possible to implement your own custom lifetime manager, which handles this for you. Actually, this is discussed in this post : 

https://stackoverflow.com/questions/1151201/singleton-per-call-context-web-request-in-unity

The question is, I have now implemented the custom lifetime manager as described in the above post, but I am unsure if this is the way to do it. I am also wondering about where the datacontext instance is disposed in the provided solution? Am I missing out something?

Is there actually a better way of solving my &quot;issue&quot;?

Thanks!



** Added information about my implementation **
-------------------------------------------------------------------------------
The following is snippets from my Global.asax, Controller and Repository. This gives a clear picture of my implementation. 

**Global.asax**

      var container = new UnityContainer();
                container
                    .RegisterType&lt;ProductsRepository&gt;(new ContainerControlledLifetimeManager())
                    .RegisterType&lt;CategoryRepository&gt;(new ContainerControlledLifetimeManager())
                    .RegisterType&lt;MyEntities&gt;(new PerResolveLifetimeManager(), dbConnectionString)



**Controller** 

    private ProductsRepository _productsRepository;
    private CategoryRepository _categoryRepository;
    
    public ProductsController(ProductsRepository productsRepository, CategoryRepository categoryRepository)
    {
       _productsRepository = productsRepository;
       _categoryRepository = categoryRepository;
    }
    
    public ActionResult Index()
    {
       ProductCategory category = _categoryRepository.GetProductCategory(categoryId);
       . 
       . 
       . 
    }

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);
        _productsRepository.Dispose();
        _categoryRepository.Dispose();
    }



**Product Repository**

    public class ProductsRepository : IDisposable
    {
    
    private MyEntities _db;
    
    public ProductsRepository(MyEntities db)
    {
        _db = db;
    }
    
    public Product GetProduct(Guid productId)
    {
        return _db.Product.Where(x =&gt; x.ID == productId).FirstOrDefault();
    }

    public void Dispose()
    {
        this._db.Dispose();
    }


**Controller Factory**

    public class UnityControllerFactory : DefaultControllerFactory
    {
        IUnityContainer _container;

        public UnityControllerFactory(IUnityContainer container)
        {
            _container = container;
        }

        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
            {
                throw new HttpException(404, String.Format(&quot;The controller for path &#39;{0}&#39; could not be found&quot; +
                    &quot;or it does not implement IController.&quot;,
                     requestContext.HttpContext.Request.Path));
            }

            return _container.Resolve(controllerType) as IController;
        }

    }


**Addition information**
Hi, I will post additional links that I come across, concerning the related issue and solution suggestions: 

 1. https://github.com/geersch/EntityFrameworkObjectContext
 2. http://dotnetslackers.com/articles/ado_net/Managing-Entity-Framework-ObjectContext-lifespan-and-scope-in-n-layered-ASP-NET-applications.aspx
 3. https://stackoverflow.com/questions/2482220/attaching-linq-to-sql-datacontext-to-httpcontext-in-business-layer
 4. http://weblogs.asp.net/shijuvarghese/archive/2008/10/24/asp-net-mvc-tip-dependency-injection-with-unity-application-block.aspx
 5. http://msdn.microsoft.com/en-us/library/bb738470.aspx





MVC, EF - DataContext singleton instance Per-Web-Request in Unity

Having the following service constructor

    public class Service : IService
    {
         public Service(IOtherService service1, IAnotherOne service2, string arg)
         {    
         }
    }

What are the choices of passing the parameters using .NET Core IOC mechanism 

 

    services.AddSingleton&lt;IOtherService , OtherService&gt;();
    services.AddSingleton&lt;IAnotherOne , AnotherOne&gt;();
    services.AddSingleton&lt;IService&gt;(x =&gt;
        new Service(
            services.BuildServiceProvider().GetService&lt;IOtherService&gt;(),
            services.BuildServiceProvider().GetService&lt;IAnotherOne &gt;(),
            &quot;&quot;));
   

 
Is there any other way ? 


.NET Core DI, ways of passing parameters to constructor

I am trying to get Unity to manage the creation of my objects and I want to have some initialization parameters that are not known until run-time:

At the moment the only way I could think of the way to do it is to have an Init method on the interface.

&lt;!-- language-all: c# --&gt;

    interface IMyIntf {
      void Initialize(string runTimeParam);
      string RunTimeParam { get; }
    }

Then to use it (in Unity) I would do this:

    var IMyIntf = unityContainer.Resolve&lt;IMyIntf&gt;();
    IMyIntf.Initialize(&quot;somevalue&quot;);

In this scenario `runTimeParam` param is determined at run-time based on user input. The trivial case here simply returns the value of `runTimeParam` but in reality the parameter will be something like file name and initialize method will do something with the file.

This creates a number of issues, namely that the `Initialize` method is available on the interface and can be called multiple times. Setting a flag in the implementation and throwing exception on repeated call to `Initialize` seems way clunky.

At the point where I resolve my interface I don&#39;t want to know anything about the implementation of `IMyIntf`. What I do want, though, is the knowledge that this interface needs certain one time initialization parameters. Is there a way to somehow annotate(attributes?) the interface with this information and pass those to framework when the object is created?

Edit: Described the interface a bit more.

Is there a pattern for initializing objects created via a DI container

I&#39;ve been using [Dependency Injection][1] (DI) for a while, injecting either in a constructor, property, or method.  I&#39;ve never felt a need to use an [Inversion of Control][2] (IoC) container.  However, the more I read, the more pressure I feel from the community to use an IoC container.

I played with .NET containers like [StructureMap](http://docs.structuremap.net), [NInject](http://www.ninject.org), [Unity](http://unity.codeplex.com), and [Funq](http://funq.codeplex.com).  I still fail to see how an IoC container is going to benefit / improve my code.

I&#39;m also afraid to start using a container at work because many of my co-workers will see code which they don&#39;t understand. Many of them may be reluctant to learn new technology.

Please, convince me that I need to use an IoC container.  I&#39;m going to use these arguments when I talk to my fellow developers at work.

  [1]: http://en.wikipedia.org/wiki/Dependency_injection
  [2]: http://en.wikipedia.org/wiki/Inversion_of_control

Why do I need an IoC container as opposed to straightforward DI code?

I&#39;m a little confused as to how the [inversion of control][1] (`IoC`) works in `Spring`.

**Say I have a service class called `UserServiceImpl` that implements `UserService` interface.**

How would this be `@Autowired`?

And in my `Controllers`, how would I `instantiate` an `instance` of this service?

Would I just do the following?

    UserService userService = new UserServiceImpl();

  [1]: http://en.wikipedia.org/wiki/Inversion_of_control


How does autowiring work in Spring?

Is it possible to register a service at run-time, meaning after the `ContainerBuilder` has been built and the `Container` has been created (and `ContainerBuilder` disposed of)?

Adding services after container has been built

I&#39;m reading theory about *dependency inversion* and *decoupling* and I can&#39;t see the difference between the two.

**Dependency inversion** talks about decoupling functional components so that higher level components don&#39;t depend on lower level components.

**Decoupling** talks about the same thing and how to achieve it. But then we have *IoC Containers* that mess things up even further. Why aren&#39;t they rather called *Dependency Inversion Containers* or even better *Dependency Injection Containers*, because they serve runtime coupling of independent components?

Then we have **Inversion of Control**. It&#39;s basically the same thing as **Dependency Inversion** isn&#39;t it? Why are there three terms that describe the same thing? Or am I blind?

1. What is the difference between the three?
2. What does IoC have to do in IoC Containers?

Difference between &quot;Inversion of Control&quot;, &quot;Dependency inversion&quot; and &quot;Decoupling&quot;

I understand the concept behind DI, but I&#39;m just learning what different IoC containers can do.  It seems that most people advocate using IoC containers to wire up stateless services, but what about using them for stateful objects like entities?

Whether it&#39;s right or wrong, I normally stuff my entities with behavior, even if that behavior requires an outside class.  Example:

    public class Order : IOrder
    {

        private string _ShipAddress;
        private IShipQuoter _ShipQuoter;

        public Order(IOrderData OrderData, IShipQuoter ShipQuoter)
        {
            // OrderData comes from a repository and has the data needed 
            // to construct order
            _ShipAddress = OrderData.ShipAddress;  // etc.
            _ShipQuoter = ShipQuoter;
            
        }

        private decimal GetShippingRate()
        {
            return _ShipQuoter.GetRate(this);
        }
    }

As you can see, the dependencies are Constructor Injected. Now for a couple of questions.

1. Is it considered bad practice to have your entities depend on outside classes such as the ShipQuoter?  Eliminating these dependencies seems to lead me towards an anemic domain, if I understand the definition correctly.

2. Is it bad practice to use an IoC container to resolve these dependencies and construct an entity when needed?  Is it possible to do this?

Thanks for any insight.

Why not use an IoC container to resolve dependencies for entities/business objects?

I get a bit confused over all the nice things laravel has to offer in terms of the IOC container and facades. Since I&#39;m not an experienced programmer it gets overwhelming to learn.

I was wondering, what is the difference between these two examples:

1. A facade to &#39;Foo&#39; and registered in the container via `App::bind()`

2. A facade to &#39;Foo&#39; and registered in the container via `App::singleton()`

In my best understanding `Foo::method()` will be rewritten as `$app-&gt;make[&#39;foo&#39;]-&gt;method()` so in the first example multiple instances of the `Foo` class will be created and in the second example, since it&#39;s bound via an `App::singleton()`, the same instance of `Foo` will be returned every time a Method on that object is called. 

I&#39;m sorry if the answer to this question is to obvious, but I can&#39;t find any confirmation on this matter and nowhere this is clearly explained.



Laravel: Difference App::bind and App::singleton

I tried the following code with Spring 3.x which failed with `BeanNotFoundException` and it should according to the answers of a question which I asked before - https://stackoverflow.com/questions/5107505/can-i-inject-same-class-using-spring  
 
    @Service
    public class UserService implements Service{
        @Autowired
        private Service self;
    }

Since I was trying this with Java 6, I found the following code works fine:

    @Service(value = &quot;someService&quot;)
    public class UserService implements Service{
        @Resource(name = &quot;someService&quot;)
        private Service self;
    }

but I don&#39;t understand how it resolves the cyclic dependency.

EDIT:  
Here&#39;s the error message. The OP mentioned it in a comment on one of the answers:

&gt; Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.spring.service.Service] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}

Self injection with Spring

How can I pull objects from the container that are transient in nature? Do I have to register them with the container and inject in the constructor of the needing class? Injecting everything into the constructor doesn&#39;t feel good. Also just for one class I don&#39;t want to create a `TypedFactory` and inject the factory  into the needing class.

Another thought that came to me was &quot;new&quot; them up on need basis. But I am also injecting a `Logger` component (through property) into all my classes. So if I new them up, I will have to manually instantiate the `Logger` in those classes. How can I continue to use the container for ALL of my classes?




***Logger injection:*** Most of my classes have the `Logger` property defined, except where there is inheritance chain (in that case only the base class has this property, and all the deriving classes use that). When these are instantiated through Windsor container, they would get my implementation of `ILogger` injected into them.

    //Install QueueMonitor as Singleton
    Container.Register(Component.For&lt;QueueMonitor&gt;().LifestyleSingleton());
    //Install DataProcessor as Trnsient
    Container.Register(Component.For&lt;DataProcessor&gt;().LifestyleTransient());

    Container.Register(Component.For&lt;Data&gt;().LifestyleScoped());

    public class QueueMonitor
    {
        private dataProcessor;

        public ILogger Logger { get; set; }

        public void OnDataReceived(Data data)
        {
            //pull the dataProcessor from factory    
            dataProcessor.ProcessData(data);
        }
    }

    public class DataProcessor
    {
        public ILogger Logger { get; set; }

        public Record[] ProcessData(Data data)
        {
            //Data can have multiple Records
            //Loop through the data and create new set of Records
            //Is this the correct way to create new records?
            //How do I use container here and avoid &quot;new&quot; 
            Record record = new Record(/*using the data */);
            ...

            //return a list of Records    
        }
    }


    public class Record
    {
        public ILogger Logger { get; set; }

        private _recordNumber;
        private _recordOwner;

        public string GetDescription()
        {
            Logger.LogDebug(&quot;log something&quot;);
            // return the custom description
        }
    }

Questions:

1. How do I create new `Record` object without using &quot;new&quot;?

2. `QueueMonitor` is `Singleton`, whereas `Data` is &quot;Scoped&quot;. How can I inject `Data` into `OnDataReceived()` method?


Windsor - pulling Transient objects from the container

I decided to start using Ninject and face an issue. Say I have the following scenario.
I have an `IService` interface and 2 classes implementing this interface. And also I have a class, which has a constructor getting IService and an __int__. How can I create an instance of this class with Ninject (I dont want to hardwire this int, I want to pass it every time I get an instance)?

Here&#39;s some code illustrating the situation:

    interface IService
    {
        void Func();
    }

    class StandardService : IService
    {
        public void Func()
        {
            Console.WriteLine(&quot;Standard&quot;);
        }
    }

    class AlternativeService : IService
    {
        public void Func()
        {
            Console.WriteLine(&quot;Alternative&quot;);
        }
    }


    class MyClass
    {
        public MyClass(IService service, int i)
        {
            this.service = service;
        }

        public void Func()
        {
            service.Func();
        }

        IService service = null;
    }
    class Program
    {
        static void Main(string[] args)
        {
            IKernel kernel = new StandardKernel(new InlineModule(
                x =&gt; x.Bind&lt;IService&gt;().To&lt;AlternativeService&gt;(),
                x =&gt; x.Bind&lt;MyClass&gt;().ToSelf()));

            IService service = kernel.Get&lt;IService&gt;();

            MyClass m = kernel.Get&lt;MyClass&gt;();
            m.Func();
        }
    }

Creating an instance using Ninject with additional parameters in the constructor

I find that my constructors are starting to look like this:

    public MyClass(Container con, SomeClass1 obj1, SomeClass2, obj2.... )

with ever increasing parameter list. Since &quot;Container&quot; is my dependency injection container, why can&#39;t I just do this:

    public MyClass(Container con)

for every class? What are the downsides? If I do this, it feels like I&#39;m using a glorified static. Please share your thoughts on IoC and Dependency Injection madness.

All Ioc Container Solutions on Gang of Coders

Total of 17 Ioc Container Solutions