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 just start study DI (I&#39;m working on WPF/Silverlight but I have a plan to move to ASP.NET). After I read some DI articles from internet there are two Frameworks that I&#39;m interested in, MEF and Unity. I want to know what is the real-world different between them and which one is good to go.

What is different between and purpose of MEF and Unity?

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

While trying to learn [Unity][1], I keep seeing the following code for overriding `GetControllerInstance` in MVC:

    if(!typeof(IController).IsAssignableFrom(controllerType)) { ... }

this seems to me a pretty convoluted way of basically writing

    if(controllerType is IController) { ... }

I appreciate there are subtle differences between `is` and `IsAssignableFrom`, ie `IsAssignableFrom` doesn&#39;t include cast conversions, but I&#39;m struggling to understand the implication of this difference in practical scenarios.

When is it imporantant to choose `IsAssignableFrom` over `is`? What difference would it make in the `GetControllerExample`?

    if (!typeof(IController).IsAssignableFrom(controllerType))
          throw new ArgumentException(...);
    return _container.Resolve(controllerType) as IController;
                


  [1]: http://weblogs.asp.net/shijuvarghese/archive/2010/05/07/dependency-injection-in-asp-net-mvc-nerddinner-app-using-unity-2-0.aspx

Use of IsAssignableFrom and &quot;is&quot; keyword in C#

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

I&#39;ve been reading the articles on MSDN about Unity (Dependency Injection, Inversion of Control), but I think I need it explained in simple terms (or simple examples). I&#39;m familiar with the MVPC pattern (we use it here), but I just can&#39;t really grasp this Unity thing yet, and I think it&#39;s the next step in our application design.

Can someone explain Microsoft Unity?

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

What&#39;s pros and cons of using Enterprise Library Unity vs other IoC containers (Windsor, Spring.Net, Autofac ..)?

Enterprise Library Unity vs Other IoC Containers

I have followed this [tutorial][1] which has worked great, until I modified my `DbContext` to have an additional constructor. I am now having issues with the resolution and not sure what to do to fix this. Is there an easy way to force it to grab the parameterless constructor or I am approaching this incorrectly? 


  [1]: http://www.asp.net/web-api/overview/extensibility/using-the-web-api-dependency-resolver

`DbContext` with two constructors:

    public class DashboardDbContext : DbContext
    {
        public DashboardDbContext() : base(&quot;DefaultConnection&quot;) { }
    
        public DashboardDbContext(DbConnection dbConnection, bool owns)
            : base(dbConnection, owns) { }
    }


`SiteController` constructor:

    private readonly IDashboardRepository _repo;

    public SiteController(IDashboardRepository repo)
    {
        _repo = repo;
    }

Repository:

    DashboardDbContext _context;

    public DashboardRepository(DashboardDbContext context)
    {
        _context = context;
    }

`UnityResolver` code:

    public class UnityResolver : IDependencyResolver
    {
        private readonly IUnityContainer _container;
    
        public UnityResolver(IUnityContainer container)
        {
            _container = container;
        }
    
        public object GetService(Type serviceType)
        {
            try
            {
                return _container.Resolve(serviceType);
            }
            catch (ResolutionFailedException)
            {
                return null;
            }
        }
    
        public IEnumerable&lt;object&gt; GetServices(Type serviceType)
        {
            try
            {
                return _container.ResolveAll(serviceType);
            }
            catch (ResolutionFailedException)
            {
                return new List&lt;object&gt;();
            }
        }
    
        public IDependencyScope BeginScope()
        {
            var child = _container.CreateChildContainer();
            return new UnityResolver(child);
        }
    
        public void Dispose()
        {
            _container.Dispose();
        }
    }

WebApiConfig:

    var container = new UnityContainer();
    container.RegisterType&lt;IDashboardRepository, DashboardRepository&gt;(new HierarchicalLifetimeManager());
    config.DependencyResolver = new UnityResolver(container);

Error from WebApi Call:

&gt; System.InvalidOperationException: An error occurred when trying to create a controller of type &#39;SiteController&#39;. Make sure that the controller has a parameterless public constructor.

    at System.Web.Http.Dispatcher.DefaultHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) 
    at System.Web.Http.Controllers.HttpControllerDescriptor.CreateController(HttpRequestMessage request) 
    at System.Web.Http.Dispatcher.HttpControllerDispatcher.SendAsyncCore(HttpRequestMessage request, CancellationToken cancellationToken) 
    at System.Web.Http.Dispatcher.HttpControllerDispatcher.&lt;SendAsync&gt;d__0.MoveNext()

&gt; InnerException: System.ArgumentException: Type &#39;Dashboard.Web.Controllers.SiteController&#39; does not have a default constructor.

    at System.Linq.Expressions.Expression.New(Type type) 
    at System.Web.Http.Internal.TypeActivator.Create[TBase](Type instanceType) 
    at System.Web.Http.Dispatcher.DefaultHttpControllerActivator.GetInstanceOrActivator(HttpRequestMessage request, Type controllerType, Func`1&amp; activator) 
    at System.Web.Http.Dispatcher.DefaultHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)

The tutorial was great and has been working well for me up until I added the second constructor.


Make sure that the controller has a parameterless public constructor error

We are using ASP.net MVC.

Which of these is the best DI framework Ninject or Unity and why?

Ninject vs Unity for DI

I am using Microsoft&#39;s Unity for dependency injection and I want to do something like this:  

    IDataContext context = _unityContainer.Resolve&lt;IDataContext&gt;();
    var repositoryA = _unityContainer.Resolve&lt;IRepositoryA&gt;(context); //Same instance of context
    var repositoryB = _unityContainer.Resolve&lt;IRepositoryB&gt;(context); //Same instance of context
    
    IDataContext context2 = _unityContainer.Resolve&lt;IDataContext&gt;(); //New instance
    var repositoryA2 = _unityContainer.Resolve&lt;IRepositoryA&gt;(context2);

`RepositoryA` and `RepositoryB` both have a constructor that takes an `IDataContext` parameter, and I want Unity to initialize the repository with the context that I pass it. Also note that `IDataContext` is not registered with Unity (I don&#39;t want 3 instances of `IDataContext`).

Can I pass constructor parameters to Unity&#39;s Resolve() method?

Has anyone had any success running using an IoC container to inject dependencies into ASP.NET WebAPI controllers? I cannot seem to get it to work.

This is what I&#39;m doing now.  

In my `global.ascx.cs`:

&lt;!-- language: c# --!&gt;

        public static void RegisterRoutes(RouteCollection routes)
        {
                // code intentionally omitted 
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);

            IUnityContainer container = BuildUnityContainer();

            System.Web.Http.GlobalConfiguration.Configuration.ServiceResolver.SetResolver(
                t =&gt;
                {
                    try
                    {
                        return container.Resolve(t);
                    }
                    catch (ResolutionFailedException)
                    {
                        return null;
                    }
                },
                t =&gt;
                {
                    try
                    {
                        return container.ResolveAll(t);
                    }
                    catch (ResolutionFailedException)
                    {
                        return new System.Collections.Generic.List&lt;object&gt;();
                    }
                });

            System.Web.Mvc.ControllerBuilder.Current.SetControllerFactory(new UnityControllerFactory(container)); 

            BundleTable.Bundles.RegisterTemplateBundles();
        }

        private static IUnityContainer BuildUnityContainer()
        {
            var container = new UnityContainer().LoadConfiguration();

            return container;
        }
    
           
My controller factory:

&lt;!-- language: c# --!&gt;

    public class UnityControllerFactory : DefaultControllerFactory
                {
                    private IUnityContainer _container;
        
                    public UnityControllerFactory(IUnityContainer container)
                    {
                        _container = container;
                    }
        
                    public override IController CreateController(System.Web.Routing.RequestContext requestContext,
                                                        string controllerName)
                    {
                        Type controllerType = base.GetControllerType(requestContext, controllerName);
        
                        return (IController)_container.Resolve(controllerType);
                    }
                }


It never seems to look in my unity file to resolve dependencies, and I get an error like:

&gt; An error occurred when trying to create a controller of type
&gt; &#39;PersonalShopper.Services.WebApi.Controllers.ShoppingListController&#39;.
&gt; Make sure that the controller has a parameterless public constructor.
&gt; 
&gt; 
&gt; at
&gt; System.Web.Http.Dispatcher.DefaultHttpControllerActivator.Create(HttpControllerContext
&gt; controllerContext, Type controllerType)
&gt;      at System.Web.Http.Dispatcher.DefaultHttpControllerFactory.CreateInstance(HttpControllerContext
&gt; controllerContext, HttpControllerDescriptor controllerDescriptor)
&gt;      at System.Web.Http.Dispatcher.DefaultHttpControllerFactory.CreateController(HttpControllerContext
&gt; controllerContext, String controllerName)
&gt;      at System.Web.Http.Dispatcher.HttpControllerDispatcher.SendAsyncInternal(HttpRequestMessage
&gt; request, CancellationToken cancellationToken)
&gt;      at System.Web.Http.Dispatcher.HttpControllerDispatcher.SendAsync(HttpRequestMessage
&gt; request, CancellationToken cancellationToken)

Controller looks like:

&lt;!-- language: c# --!&gt;

    public class ShoppingListController : System.Web.Http.ApiController
        {
            private Repositories.IProductListRepository _ProductListRepository;
    
    
            public ShoppingListController(Repositories.IUserRepository userRepository,
                Repositories.IProductListRepository productListRepository)
            {
                _ProductListRepository = productListRepository;
            }
    }

My unity file looks like:

    &lt;unity xmlns=&quot;http://schemas.microsoft.com/practices/2010/unity&quot;&gt;
      &lt;container&gt;
        &lt;register type=&quot;PersonalShopper.Repositories.IProductListRepository, PersonalShopper.Repositories&quot; mapTo=&quot;PersonalShopper.Implementations.MongoRepositories.ProductListRepository, PersonalShopper.Implementations&quot; /&gt;
      &lt;/container&gt;
    &lt;/unity&gt;

Note that I don&#39;t have a registration for the controller itself because in previous versions of mvc the controller factory would figure out that the dependencies needed to be resolved.

It seems like my controller factory is never being called.


Cannot Inject Dependencies into ASP.NET Web API Controller using Unity

Yesterday I&#39;ve implemented the code:

    CustomerProductManager productsManager = container.Resolve&lt;CustomerProductManager&gt;();

It was compilable and working.

Today (probably I&#39;ve modified something) I am constantly getting the error:

&gt; The non-generic method
&gt; &#39;Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,
&gt; string, params
&gt; Microsoft.Practices.Unity.ResolverOverride[])&#39;
&gt; cannot be used with type arguments

My collegue has the same source code and doesn&#39;t have same error. Why? How to resolve the problem?

P.S. 

line &quot;using Microsoft.Practices.Unity;&quot; is present in usings section.

I&#39;ve tried to replace generic version with non-generic one:

    CustomerProductManager productsManager = (CustomerProductManager)container.Resolve(typeof(CustomerProductManager));

And got another error:

&gt; No overload for method &#39;Resolve&#39; takes
&gt; &#39;1&#39; arguments

It seems like one of the assemblies is not referenced.. but which one? I have 2 of them referenced:
1. Microsoft.Practices.Unity.dll
2. Microsoft.Practices.ServiceLocation.dll

P.P.S. I&#39;ve saw similar problem http://unity.codeplex.com/WorkItem/View.aspx?WorkItemId=8205 but it is resolved as &quot;not a bug&quot;

Any thought will be helpful

IUnityContainer.Resolve&lt;T&gt; throws error claiming it cannot be used with type parameters

I have the `IRespository` registered twice (with names) in the following code:

    // Setup the Client Repository
    IOC.Container.RegisterType&lt;ClientEntities&gt;(new InjectionConstructor());
    IOC.Container.RegisterType&lt;IRepository, GenericRepository&gt;
        (&quot;Client&quot;, new InjectionConstructor(typeof(ClientEntities)));
    
    // Setup the Customer Repository
    IOC.Container.RegisterType&lt;CustomerEntities&gt;(new InjectionConstructor());
    IOC.Container.RegisterType&lt;IRepository, GenericRepository&gt;
        (&quot;Customer&quot;, new InjectionConstructor(typeof(CustomerEntities)));

    IOC.Container.RegisterType&lt;IClientModel, ClientModel&gt;();
    IOC.Container.RegisterType&lt;ICustomerModel, CustomerModel&gt;();

But then when I want to resolve this (to use the `IRepository`) I have to do a manual resolve like this:

    public ClientModel(IUnityContainer container)
    {
       this.dataAccess = container.Resolve&lt;IRepository&gt;(Client);

       .....
    }

What I would like to do is to have it resolved in the constructor (just like `IUnityContainer`). I need some way to say which named type to resolve to.

Something like this: **(NOTE: Not real code)**

    public ClientModel([NamedDependancy(&quot;Client&quot;)] IRepository dataAccess)
    {
       this.dataAccess = dataAccess;

       .....
    }

Is there a way to make my fake code work?

With Unity how do I inject a named dependency into a constructor?

Looking at Microsoft&#39;s Managed Extensibility Framework (MEF) and various IoC containers (such as Unity), I am failing to see when to use one type of solution over the other.  More specifically, it seems like MEF handles most IoC type patterns and that an IoC container like Unity would not be as necessary.  

Ideally, I would like to see a good use case where an IoC container would be used instead of, or in addition to, MEF. 

MEF vs. any IoC

The Unity dependency injection container has what seems to be a widely known issue where the SynchronizedLifetimeManager will often cause the Monitor.Exit method to throw a SynchronizationLockException which is then caught and ignored. This is a problem for me because I like to debug with Visual Studio set to break on any thrown exception, so every time my application starts up I&#39;m breaking on this exception multiple times for no reason.

**How can I prevent this exception from being thrown?**

Wherever this issues is mentioned elsewhere on the web, the advice usually involves changing the debugger settings to ignore it. This is akin to going to the doctor and saying, &quot;Doctor, Doctor, my arm hurts when I raise it,&quot; to be told, &quot;Well, stop raising it.&quot; I&#39;m looking for a solution that stops the exception being thrown in the first place.

The exception occurs in the SetValue method because it makes the assumption that GetValue will have been called first, where Monitor.Enter is called. However, the LifetimeStrategy and UnityDefaultBehaviorExtension classes both regularly call SetValue without calling GetValue.

I&#39;d rather not have to change the source code and maintain my own version of Unity, so I&#39;m hoping for a solution where I can add some combination of extensions, policies, or strategies to the container that will ensure that, if the lifetime manager is a SynchronizedLifetimeManager, GetValue is always called before anything else.

All Unity Container Solutions on Gang of Coders

Total of 16 Unity Container Solutions