Simple Injector unable to inject dependencies in Web API controllers

by

TLTR: the problem is caused by the implicit way Web API handles resolving controller types; register your Web API controllers explicitly and you’ll see where the problem is.

Here is a step by step what is happening under the covers:

  1. The System.Web.Http.DefaultHttpControllerActivator calls into the SimpleInjectorWebApiDependencyResolver and requests the creation of an API controller.
  2. SimpleInjectorWebApiDependencyResolver forwards that call to the SimpleInjector.Container instance.
  3. That Container instance however, does not have any explicit registrations for that API Controller (since you supplied an empty container to the resolver).
  4. Since there is no explicit registration, the container tries to do a last minute registration for that type.
  5. That Controller type however depends on interfaces that can’t be resolved because they are not registered in the container (remember, your container is empty).
  6. Although the container would normally throw an exception, null is returned in this case, because the type is requested through the IServiceProvider.GetService method and the type was not registered explictly.
  7. The SimpleInjectorWebApiDependencyResolver‘s GetService method will return null as well, since it’s by definition that it should return null; It should return null when no registration exists (which currently is the case).
  8. Since the DependencyResolver returned null, DefaultHttpControllerActivator will fall back to its default behavior, which means creating that type itself, but this requires the controller to have a default constructor.

Long story short, the problem is caused by the implicit way Web API handles resolving controller types.

So the solution here is to:

  1. Have only one single Container in your web application. This prevents all sorts of trouble and complication of your configuration.
  2. Register all Web API Controllers explicitly in the container. Registering controllers explicitly will ensure that Simple Injector will throw an exception when a controller can’t be resolved. Besides, this allows you to call container.Verify() which will make the application fail during startup when the configuration is invalid (a verifiable configuration is important). And this also allows you to diagnose the configuration which gives you even more confidence about the correctness of your configuration.

My advice is to place MVC and Web API in their own project. This will make things much easier.

Registering all Web API controllers can be done with the following code:

container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

UPDATE:

Because this error is so common, newer versions of the SimpleInjectorWebApiDependencyResolver class will simply never return null when a controller type is requested. Instead it will throw a descriptive error. Because of this you should never see error anymore, as long as you use the official SimpleInjectorWebApiDependencyResolver.

More Related Contents:

  1. Using DI container in unit tests
  2. log4net with DI Simple Injector
  3. How to use DI container when OwinStartup
  4. Simple Injector: Register ILogger by using ILoggerFactory.CreateLogger()
  5. Constructor injection with Quartz.NET and Simple Injector
  6. .NET HttpClient. How to POST string value?
  7. Adding Http Headers to HttpClient
  8. Make sure that the controller has a parameterless public constructor error
  9. FromBody string parameter is giving null
  10. Why is HttpContext.Current null after await?
  11. JSON.NET Parser *seems* to be double serializing my objects
  12. Injecting dependencies into ASP.NET MVC 3 action filters. What’s wrong with this approach?
  13. Deserialising JSON to derived types in Asp.Net Web API
  14. Can I pass constructor parameters to Unity’s Resolve() method?
  15. How to set up a Web API controller for multipart/form-data
  16. Serialize a container of enums as strings using JSON.net
  17. web-api POST body object always null
  18. Hangfire – Multi tenant, ASP.NET Core – Resolving the correct tenant
  19. Dependency Injection vs Service Location
  20. How to to return an image with Web API Get method
  21. TempData null in asp.net core
  22. Unable to resolve service for type while attempting to activate
  23. Register IAuthenticationManager with Simple Injector
  24. Using ADAL C# as Confidential User /Daemon Server /Server-to-Server – 401 Unauthorized
  25. Replace service registration in ASP.NET Core built-in DI container?
  26. How do I inject ASP.NET 5 (vNext) user-secrets into my own utility class?
  27. How can I register a generic decorator using Castle Windsor?
  28. Best practice for error handling with ASP.NET Web API
  29. Is there a way in Json.NET serialization to distinguish between “null because not present” and “null because null”?
  30. What is the difference between DependencyResolver.SetResolver and HttpConfiguration.DependencyResolver in WebAPI

Leave a Comment