添加Owin后，依赖注入中断，没有为此对象定义的无参数构造函数

Question

I have a problem regarding dependency injection in my project, it was working fine before implementing Owin. After I added Owin and made a startup class Issues started to appear. There is quite some documentation on the issue already. But I can't seem to resolve it using any of the other posts about this matter.

The services involved indeed do have a parameterless constructor, the controller has one too, the service stays empty.

I am using the following packages:

• Unity (v3.5.1404)
• Unity.WebApi.5.1 (v5.2.0)
• Microsoft.AspNet.SignalR.Owin (v1.2.2)
• Microsoft.AspNet.WebApi.Owin (v5.2.3)
• Microsoft.AspNet.WebApi.OwinSelfHost (v5.2.3)
• Microsoft.Owin (v3.0.1)
• Microsoft.Owin.Security (v1.0.0)
• Microsoft.Owin.Host.SystemWeb (v3.0.1)
• Owin (v1.0.0)
• Microsoft.Owin.Host.SystemWeb (v3.0.1)

Whenever I browse to a controller that requires dependency injection the following error occurs.

 [MissingMethodException: No parameterless constructor defined for this object.]
       System.RuntimeTypeHandle.CreateInstance(RuntimeType type, Boolean publicOnly, Boolean noCheck, Boolean& canBeCached, RuntimeMethodHandleInternal& ctor, Boolean& bNeedSecurityCheck) +0
       System.RuntimeType.CreateInstanceSlow(Boolean publicOnly, Boolean skipCheckThis, Boolean fillCache, StackCrawlMark& stackMark) +119
       System.RuntimeType.CreateInstanceDefaultCtor(Boolean publicOnly, Boolean skipCheckThis, Boolean fillCache, StackCrawlMark& stackMark) +232
       System.Activator.CreateInstance(Type type, Boolean nonPublic) +83
       System.Activator.CreateInstance(Type type) +11
       System.Web.Mvc.DefaultControllerActivator.Create(RequestContext requestContext, Type controllerType) +55

    [InvalidOperationException: An error occurred when trying to create a controller of type '_Servicebus.Controllers.AuthenticationController'. Make sure that the controller has a parameterless public constructor.]
       System.Web.Mvc.DefaultControllerActivator.Create(RequestContext requestContext, Type controllerType) +178
       System.Web.Mvc.DefaultControllerFactory.GetControllerInstance(RequestContext requestContext, Type controllerType) +76
       System.Web.Mvc.DefaultControllerFactory.CreateController(RequestContext requestContext, String controllerName) +88
       System.Web.Mvc.MvcHandler.ProcessRequestInit(HttpContextBase httpContext, IController& controller, IControllerFactory& factory) +194
       System.Web.Mvc.MvcHandler.BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, Object state) +50
       System.Web.Mvc.MvcHandler.BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, Object state) +48
       System.Web.Mvc.MvcHandler.System.Web.IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData) +16
       System.Web.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +103
       System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously) +155 

I believe it has to do with Global.asax.cs and Startup.cs.

Global.asax.cs:

 using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.Http;
    using System.Web.Mvc;
    using System.Web.Optimization;
    using System.Web.Routing;
    using System.Timers;
    using Microsoft.Practices.Unity;
    using BusinessLayer.HourRegistration.Services;
    using BusinessLayer.HourRegistration.Interfaces;
    using DataAccessLayer.HourRegistration.Repositories;
    using DataAccessLayer.HourRegistration.Entities;
    using System.Data.Entity;
    using System.IO;

    namespace Servicebus
    {
        public class WebApiApplication : System.Web.HttpApplication
        {

            Timer timer;
            bool firsttime;
            protected void Application_Start()
            {
                AreaRegistration.RegisterAllAreas();
                GlobalConfiguration.Configure(WebApiConfig.Register);
                FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                BundleConfig.RegisterBundles(BundleTable.Bundles);
                /*firsttime = true;
                timer = new Timer();
                timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
                timer.Interval = 20000;
                timer.AutoReset = false;
                timer.Start();*/
            }

            private ICrmUserFilterRepository uService
            {
                get
                {
                    return GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof(ICrmUserFilterRepository)) as ICrmUserFilterRepository;
                }
            }

            private IHourRegistrationService hService
            {
                get
                {
                    return GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof(IHourRegistrationService)) as IHourRegistrationService;
                }
            }

            private void timer_Elapsed(object sender, ElapsedEventArgs e)
            {
                if (firsttime)
                {
                    firsttime = false;
                    timer.Stop();
                    List<CrmUserFilter> tempList = uService.GetAll().ToList();
                    hService.setFourWeeksOldClosed();
                    CrmFetchXml.getCrmFetchXmlInstance.reload24HoursCache(tempList);
                    timer.Interval = GetTimeUntilNextCacheRefresh(2);
                    timer.Start();
                }
                else {
                    timer.Stop();
                    List<CrmUserFilter> tempList = uService.GetAll().ToList();
                    hService.setFourWeeksOldClosed();
                    CrmFetchXml.getCrmFetchXmlInstance.reload24HoursCache(tempList);
                    timer.Interval = GetTimeUntilNextCacheRefresh(2);
                    timer.Start();
                }
            }

            public static double GetTimeUntilNextCacheRefresh(int hour)
            {
                var currentTime = DateTime.Now;
                var desiredTime = new DateTime(DateTime.Now.Year,
                    DateTime.Now.Month, DateTime.Now.Day, hour, 0, 0);
                var timeDifference = (currentTime - desiredTime);
                var timePeriod = currentTime.Hour >= hour ?
                    (desiredTime.AddDays(1) - currentTime) :
                    -timeDifference;
                return Convert.ToInt32(timePeriod.TotalMilliseconds);
            }
        }
    }

Startup.cs:

  using Microsoft.AspNet.Identity;
using Microsoft.Owin;
using Microsoft.Owin.Security.Cookies;
using Microsoft.Practices.Unity;
using Owin;
using System.Security.Claims;
using System.Web.Helpers;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using Unity.WebApi;

[assembly: OwinStartup(typeof(Servicebus.App_Start.Startup))]

namespace Servicebus.App_Start
{
    public partial class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
        }
        public void ConfigureAuth(IAppBuilder app)
        {
            //unity fix
            HttpConfiguration config = new HttpConfiguration();

            UnityContainer container = WebApiConfig.Register(config);

            // ... Configure you web api routes
            config.DependencyResolver = new UnityDependencyResolver(container);

            app.UseWebApi(config);
            //GlobalConfiguration.Configure(config);
            //app.UseWebApi(GlobalConfiguration.DefaultServer);


            // Enable the application to use a cookie to store information for the signed in user
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Authentication/Login")
            });

            //app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;
        }
    }
}

WebApiConfig.cs:

        using System.Web.Http;
        using Microsoft.Practices.Unity;
        using BusinessLayer.HourRegistration.Interfaces;
        using BusinessLayer.HourRegistration.Services;
        using DataAccessLayer.HourRegistration.Repositories;
        using System.Net.Http.Formatting;
        using System.Data.Entity;
        using Unity.WebApi;
        using System.Web.Mvc;
        using Servicebus.Security;
        using System.Diagnostics;
        using BusinessLayer.MTO.Interfaces;
        using DataAccessLayer.MTO.Repositories.InterfaceRepositories;
        using BusinessLayer.MTO.Services;
        using DataAccessLayer.MTO.Repositories;
        using DataAccessLayer.Common.DatabaseFactory;
        using DataAccessLayer.HourRegistration.UnitOfWork;
        using DataAccessLayer.MTO.UnitOfWork;

        namespace Servicebus
        {
            public static class WebApiConfig
            {
                public static UnityContainer Register(HttpConfiguration config)
                {

                    config.EnableCors();

                    UnityContainer container = new UnityContainer();
container.RegisterType<IAuthenticationService, AuthenticationService>();
                    container.RegisterType<IDatabaseFactory, DatabaseFactory>(new PerResolveLifetimeManager());
                    container.RegisterType<IUnitOfWorkHourregistration, UnitOfWorkHourregistration>();
                    container.RegisterType<ICrmProjectRepository, CrmProjectRepository>();
                    container.RegisterType<ICrmOrderRepository, CrmOrderRepository>();
                    container.RegisterType<IHourRegistrationRepository, HourRegistrationRepository>();
                    container.RegisterType<IOverTimeHoursRepository, OverTimeHoursRepository>();
                    container.RegisterType<IWorkhoursRepository, WorkHoursRepository>();
                    container.RegisterType<IRoleRepository, RoleRepository>();
                    container.RegisterType<IUserRepository, UserRepository>();
                    container.RegisterType<IHourRegistrationService, HourRegistrationService>();
                    container.RegisterType<IRoleProviderService, RoleProviderService>();
                    container.RegisterType<ICrmUserFilterRepository, CrmUserFilterRepository>();

                    //for MTO
                    container.RegisterType<IMTOService, MTOService>();
                    container.RegisterType<IUnitOfWorkMTO, UnitOfWorkMTO>();
                    container.RegisterType<IMtoRepository, MtoRepository>();
                    container.RegisterType<IChapterRepository, ChapterRepository>();
                    container.RegisterType<IQuestionRepository, QuestionRepository>();
                    container.RegisterType<IQuestionKindRepository, QuestionKindRepository>();
                    container.RegisterType<IAnswerRepository, AnswerRepository>();
                    container.RegisterType<IDepartmentRepository, DepartmentRepository>();
                    container.RegisterType<IReportRepository, ReportRepository>();
                    container.RegisterType<IActionPointRepository, ActionPointRepository>();
                    container.RegisterType<IUserMtoRepository, UserMtoRepository>();
                    container.RegisterType<IRoleMtoRepository, RoleMtoRepository>();
                    container.RegisterType<IMtoUserResponseRepository, MtoUserResponseRepository>();

                    config.DependencyResolver = new UnityDependencyResolver(container);
                    config.Formatters.JsonFormatter.MediaTypeMappings.Add(new UriPathExtensionMapping("json", "application/json"));

                    config.Formatters.XmlFormatter.MediaTypeMappings.Add(new UriPathExtensionMapping("xml", "application/xml"));


                    // Web API routes
                    config.MapHttpAttributeRoutes();

                    config.Routes.MapHttpRoute(
                        name: "DefaultApi",
                        routeTemplate: "api/{controller}/{id}",
                        defaults: new { id = RouteParameter.Optional }
                    );
                    config.Routes.MapHttpRoute(
                        name: "Api UriPathExtension",
                        routeTemplate: "api/{controller}.{ext}/{id}",
                        defaults: new { id = RouteParameter.Optional }
                    );
                    config.Routes.MapHttpRoute(
                        name: "MtoApi",
                        routeTemplate: "api/{controller}/{id}",
                        defaults: new { controller = "mto", id = RouteParameter.Optional }
                        );
                    return container;
                }
            }
        }

The services involved indeed do have a parameterless constructor, the controller has one too, the service stays empty.

A random [unfinished] service:

using BusinessLayer.Authentication.Interfaces;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BusinessLayer.Authentication.Services
{
    public class AuthenticationService : IAuthenticationService
    {

        public AuthenticationService()
        { }

        public bool CheckRedirects(string applicationName, string jsonString)
        {
            JObject jsonObj = JObject.Parse(jsonString);
            ////Exists? --> Search in JSON.
            foreach (KeyValuePair<string, JToken> sub_obj in (JObject)jsonObj["Redirects"])
            {

            }

            return true;
        }
    }
}

AuthenticationController.cs:

using BusinessLayer.Authentication.Interfaces;
using Microsoft.AspNet.Identity;
using Microsoft.Owin.Security;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;
using System.Web.Http.Cors;
using System.Web.Mvc;

namespace Servicebus.Controllers
{
    [System.Web.Mvc.AllowAnonymous]
    [EnableCors(origins: "*", headers: "*", methods: "*")]
    public class AuthenticationController : Controller
    {

        /// <summary>
        /// Service from the business layer to get the right information
        /// </summary>
        public IAuthenticationService aService;
        /// <summary>
        /// Constructor of the hourregistation controller gets the service from the unity container.
        /// </summary>

        public AuthenticationController(IAuthenticationService aService)
        {
            this.aService = aService;
        }

        public ActionResult Login()
        {
            NameValueCollection queryString = Request.QueryString;
            aService.CheckRedirects(queryString["applicationType"], System.IO.File.ReadAllText(Server.MapPath(Url.Content("~/Content/loginRedirects.json"))));


            String state = Guid.NewGuid().ToString();
            String url = this.Url.Action("Callback", "Authentication", null, this.Request.Url.Scheme).ToString();
            return Redirect(removed);
        }

        public ActionResult Callback()
        {
            NameValueCollection queryString = Request.QueryString;
            if (!queryString["code"].Equals(null))
            {
                IdentityStore(queryString["code"], queryString["state"]);
            }

            return null;
        }

        private void IdentityStore(string authToken, string queryString, bool isPersistent = false)
        {
            var claims = new List<Claim>();
            claims.Add(new Claim(ClaimTypes.NameIdentifier, authToken));
            claims.Add(new Claim("state", queryString));

            var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie);

            AuthenticationManager.SignIn(new AuthenticationProperties()
            {
                AllowRefresh = true,
                IsPersistent = isPersistent,
                ExpiresUtc = DateTime.UtcNow.AddDays(7)
            }, identity);
        }

        private IAuthenticationManager AuthenticationManager
        {
            get
            {
                return HttpContext.GetOwinContext().Authentication;
            }
        }

        public void IdentitySignout()
        {

            AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie, DefaultAuthenticationTypes.ExternalCookie);
        }
    }
}

Any help is appreciated.

Regards!

Answer 1

Basically, you need to make sure that all your dependencies are registered in the OWIN startup class, because the global won't be used for the WebApi pipeline.

You can use shared containers as well for the dependency containers so that you're not initialising two separate instances.

The quick fix:

namespace Servicebus.App_Start
{
    public partial class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            WebApiConfig.Register(new HttpConfiguration());
            ConfigureAuth(app);
        }
    }
}

Unity comes with an activator which Provides the bootstrapping for integrating Unity with WebApi when it is hosted in ASP.NET according to its own documentation.

This is the nuget:

<package id="Unity.AspNet.WebApi" version="3.5.1405-prerelease" targetFramework="net45" />

I advise you implement that

Important Package

<package id="Microsoft.Owin.Host.SystemWeb" version="3.0.1" targetFramework="net45" />

Have you got this?

Final Thoughts

I always find it a good idea to make a small project with just the the infrastructure bits - see if you can get a basic website up and running. If you can do this then you should be able to debug yourself what the issue is.

If you can't get a simple website running on your machine - try another machine - if all else fails then you have serious problems. I have got many of these types of projects up and running so it should be straightforward.

Answer 2

As it turns out, dependency injection in a regular controller does not work using Unity. Making changes to the controller has resolved the issue.

The controller now looks like this:

        using Microsoft.AspNet.Identity;
        using Microsoft.Owin.Security;
        using Newtonsoft.Json.Linq;
        using System;
        using System.Collections.Generic;
        using System.Collections.Specialized;
        using System.Diagnostics;
        using System.IO;
        using System.Linq;
        using System.Net.Http;
        using System.Security.Claims;
        using System.Threading.Tasks;
        using System.Web;
        using System.Web.Http;
        using System.Web.Http.Cors;
        using System.Web.Mvc;

        namespace Servicebus.Controllers
        {
            [System.Web.Mvc.AllowAnonymous]
            [EnableCors(origins: "*", headers: "*", methods: "*")]
            public class AuthenticationController : Controller
            {

                /// <summary>
                /// Service from the business layer to get the right information
                /// </summary>
                private IAuthenticationService _aService
                {
                    get
                    {
                        return GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof(IAuthenticationService)) as AuthenticationService;
                    }
                }
                /// <summary>
                /// Constructor of the hourregistation controller gets the service from the unity container.
                /// </summary>
                public AuthenticationController()
                {

                }
//other functions
    }
    }