Unity 4(IOC) + MVC 5 unable to resolve types during startup

Question

I'm using Unity 4 (through NuGet) with ASP.NET MVC 5. I've modified all my controller and business classes to receive their dependencies as interfaces through their constructors.

The boostrapper class contains the following code:

public class Bootstrapper
{
    public static IUnityContainer UnityContainer { get; set; }

    public static void Initialize()
    {
        InitializeUnity();
        RegisterTypes();
    }

    private static void InitializeUnity()
    {
        UnityContainer = UnityConfig.GetConfiguredContainer();
        DependencyResolver.SetResolver(new UnityDependencyResolver(UnityContainer));
    }

    private static void RegisterTypes()
    {
        new Core.Bootstrapper().RegisterTypes(UnityContainer);
    }
}

The content of Core.Bootstrapper().RegisterTypes is as follows:

public IUnityContainer RegisterTypes(IUnityContainer container)
{
    // Register repositories
    container.RegisterType<IRepository, Repository>()
             .RegisterType<IBdeRepository, BdeRepository>()
             .RegisterType<IDocumentRepository, DocumentRepository>()
             .RegisterType<IHampRepository, HampRepository>()
             .RegisterType<IReportsRepository, ReportsRepository>()
             .RegisterType<ITransactionRepository, TransactionRepository>();

    // Register commands
    container.RegisterType<IBaseCommand, BaseCommand>()
             .RegisterType<IDailyLetterInfoUpdate, DailyLetterInfoUpdate>()
             .RegisterType<IDailyReconciliation, DailyReconciliation>()
             .RegisterType<InsertNewRows, InsertNewRows>()
             .RegisterType<IOrderDailyLM023, OrderDailyLM023>()
             .RegisterType<IOrderMonthlyLM012, OrderMonthlyLM012>()
             .RegisterType<IOrderMonthlyLM014, OrderMonthlyLM014>()
             .RegisterType<IPerformMonthlyRecastStatusUpdate, PerformMonthlyRecastStatusUpdate>()
             .RegisterType<IUpdateReissuedRecasts, UpdateReissuedRecasts>();

    // Register utility types
    container.RegisterType<ICsvExporter, CsvExporter>()
             .RegisterType<ILogger, Logger>();

    return container;
}

Finally, both UnityConfig.cs and UnityMvcActivator.cs remain unmodified from what they were when they were first installed by the NuGet package.

When I start my MVC application, I am confronted with the following error message:

Resolution of the dependency failed, type = "System.Web.Mvc.ITempDataProviderFactory", name = "(none)".

Exception occurred while: while resolving.

Exception is: InvalidOperationException - The current type, System.Web.Mvc.ITempDataProviderFactory, is an interface and cannot be constructed. Are you missing a type mapping?

The class it mentions appears to be something internal to MVC, itself, which leads me to believe that I've either missed something in configuring Unity, or that I've whacked something in doing so. For the life of me, however, I can't figure out what it is, despite having consulted virtually every question I can find regarding the error message on StackOverflow. (None of the proposed solutions have resolved the issue so far, but it's quite likely I've missed something.)

Can anyone see something I've overlooked? What am I doing wrong?

UPDATE:

The exception is thrown here:

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    routes.MapMvcAttributeRoutes(); // Exception thrown on this line.
}

Yes. See the update for more information about where the exception is thrown. — Mike Hofer, Mar 08 '17 at 14:33
Did you tried to register manually `ITempDataProviderFactory`? It looks like that default implementation is missing. Maybe is some bug or some version mismatch. It is interesting post, please post answer if you find solution. — kat1330, Mar 08 '17 at 20:31

score 3 · Answer 1 · answered Jul 03 '17 at 14:22

Here's a slightly different implementation with specific exclusions for the MVC parts, adapted from the code at UnityDependencyResolver.cs

Seems to be a slight performance advantage at startup but main thing is that you don't get 10 exceptions raised.

/// <summary>
/// Resolves dependencies against the current DI container.
/// </summary>
public class UnityDependencyResolver : IDependencyResolver
{
    private readonly IUnityContainer container;
    // NB Not likely to be be big but will be frequent so use HashSet as O(1) lookup cost - see https://stackoverflow.com/questions/18651940/performance-benchmarking-of-contains-exists-and-any
    private readonly HashSet<Type> excludedTypes;

    /// <summary>
    /// Initializes a new instance of the <see cref="UnityDependencyResolver"/> class.
    /// </summary>
    /// <param name="container">The container.</param>
    public UnityDependencyResolver(IUnityContainer container)
    {
        this.container = container;
        excludedTypes = new HashSet<Type>();

        StandardExclusions();
    }

    /// <summary>
    /// Resolves an instance of the default requested type from the container.
    /// </summary>
    /// <param name="serviceType">The <see cref="Type"/> of the object to get from the container.</param>
    /// <returns>The requested object.</returns>
    public object GetService(Type serviceType)
    {
        if (typeof(IController).IsAssignableFrom(serviceType))
        {
            return container.Resolve(serviceType);
        }

        try
        {
            return excludedTypes.Contains(serviceType) ? null : container.Resolve(serviceType);
        }
        catch (ResolutionFailedException)
        {
            return null;
        }
    }

    /// <summary>
    /// Resolves multiply registered services.
    /// </summary>
    /// <param name="serviceType">The type of the requested services.</param>
    /// <returns>The requested services.</returns>
    public IEnumerable<object> GetServices(Type serviceType)
    {
        return container.ResolveAll(serviceType);
    }

    public void Exclude<T>()
    {
        Exclude(typeof(T));
    }

    public void Exclude(Type type)
    {
        excludedTypes.Add(type);
    }

    public void Include<T>()
    {
        Include(typeof(T));
    }

    public void Include(Type type)
    {
        excludedTypes.Remove(type);
    }

    private void StandardExclusions()
    {
        Exclude<System.Web.Mvc.IControllerFactory>();
        Exclude<System.Web.Mvc.IControllerActivator>();
        Exclude<System.Web.Mvc.ITempDataProviderFactory>();
        Exclude<System.Web.Mvc.ITempDataProvider>();
        Exclude<System.Web.Mvc.Async.IAsyncActionInvokerFactory>();
        Exclude<System.Web.Mvc.IActionInvokerFactory>();
        Exclude<System.Web.Mvc.Async.IAsyncActionInvoker>();
        Exclude<System.Web.Mvc.IActionInvoker>();
        Exclude<System.Web.Mvc.IViewPageActivator>();
        Exclude<System.Web.Mvc.ModelMetadataProvider>();
    }
}

If you do override one of the standard MVC interfaces, then you can remove it from the exclusion list with

var resolver = new UnityDependencyResolver(container);
resolver.Include<System.Web.Mvc.IActionInvoker>();

score 0 · Accepted Answer · answered Mar 09 '17 at 20:36

I found the solution to my particular scenario, and it was kind of surprising.

I had to roll my own DependencyResolver class and use it in lieu of the MVC resolver provided by Unity. The resolver I wrote is as follows:

using System;
using System.Collections.Generic;
using System.Web.Mvc;

using Microsoft.Practices.Unity;

/// <summary>
/// Resolves dependencies against the current DI container.
/// </summary>
public class UnityDependencyResolver : IDependencyResolver
{
    /// <summary>
    /// The container
    /// </summary>
    private readonly IUnityContainer container;

    /// <summary>
    /// Initializes a new instance of the <see cref="UnityDependencyResolver"/> class.
    /// </summary>
    /// <param name="container">The container.</param>
    public UnityDependencyResolver(IUnityContainer container) 
    {
        this.container = container;
    }

    /// <summary>
    /// Resolves an instance of the default requested type from the container.
    /// </summary>
    /// <param name="serviceType">The <see cref="Type"/> of the object to get from the container.</param>
    /// <returns>The requested object, if it can be resolved; otherwise, <c>null</c>.</returns>
    public object GetService(Type serviceType)
    {
        return this.container.IsRegistered(serviceType) 
            ? this.container.Resolve(serviceType) 
            : null;
    }

    /// <summary>
    /// Resolves multiply registered services.
    /// </summary>
    /// <param name="serviceType">The type of the requested services.</param>
    /// <returns>The requested services.</returns>
    public IEnumerable<object> GetServices(Type serviceType)
    {
        return this.container.ResolveAll(serviceType);
    }
}

The most important part was the implementation of GetService: It must return null if it can't resolve a type, otherwise, MVC goes belly-up and throws an exception with the message, "XXX is an interface, and can't be constructed. Are you missing a binding?"

This, of course changed the behavior of this line of code in Bootstrapper.cs:

DependencyResolver.SetResolver(
    new UnityDependencyResolver(UnityContainer));

It uses the local implementation instead of the default Unity implementation.

What's weird about this is that the sample app I'm drawing from works locally on my machine, and it isn't using a custom resolver. It works fine without this class. I don't know why this worked, and that's troubling (I prefer deterministic answers to questions), but at this point I'm just happy I can get back to work.

Mike. the only downside to your method is that Unity is not very efficient with IsRegistered, so on a large container it might take more time than the exception throw — Paul Hatcher, Jul 03 '17 at 13:29

Unity 4(IOC) + MVC 5 unable to resolve types during startup

2 Answers2