MVC MEF Error: Make sure that the controller has a parameterless public constructor

Question

For MVC app using MEF, sometimes I get the erorr ""

I have a .NET solution with

1. One MVC Web application project and,
2. Many class libraries projects which take care of authentication, getting configurations, making external API calls etc.

I have configured the MEF as shown below through the code and deployed this on Web Server using IIS. Observed the below error couple of times, after which I tried to load the page multiple times but it still throws the same error.

Once I refreshed the application pool, then only the error disappears. I had been trying hard to debug and understand the error, but with no success. Am I misconfiguring MEF anywhere?

Global.asax:

public class Global : HttpApplication
  {
    void Application_Start(object sender, EventArgs e)
    {
      AreaRegistration.RegisterAllAreas();
      GlobalConfiguration.Configure(WebApiConfig.Register);
      RouteConfig.RegisterRoutes(RouteTable.Routes);

      var pluginFolders = LoadMefComponents();
      Bootstrapper.Compose(pluginFolders);
      IControllerFactory mefControllerFactory = new MefControllerFactory(Bootstrapper.Container);
      ControllerBuilder.Current.SetControllerFactory(mefControllerFactory);
    }

    protected List<string> LoadMefComponents()
    {
      var pluginFolders = new List<string>();
      string ModulesPath = CommonUtility.GetApplicationDirectory();
      var plugins = Directory.GetDirectories(ModulesPath).ToList();
      plugins.ForEach(path =>
      {
        var directoryInfo = new DirectoryInfo(path);
        pluginFolders.Add(directoryInfo.Name);
      });
      return pluginFolders;
    }
  }

MEFControllerFactory.cs: This file resides in App_Start

public class MefControllerFactory : DefaultControllerFactory
    {
        private readonly CompositionContainer _container;
        private readonly Dictionary<IController, Lazy<object, object>> exports;
        private readonly object syncRoot;

        public MefControllerFactory(CompositionContainer container)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            this._container = container;
            this.exports = new Dictionary<IController, Lazy<object, object>>();
            this.syncRoot = new object();

        }

        protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
        {
            Lazy<object, object> export = _container.GetExports(controllerType, null, null).FirstOrDefault();

            var controller = null == export ? base.GetControllerInstance(requestContext, controllerType)
                                : (IController)export.Value;
            lock (this.syncRoot)
            {
                this.exports.Add(controller, export);
            }
            return controller;
        }

        public override void ReleaseController(IController controller)
        {
            lock (this.syncRoot)
            {
                var export = this.exports[controller];
                this.exports.Remove(controller);
               // this._container.ReleaseExport(export);
            }
            ((IDisposable)controller).Dispose();
        }
    }

Bootstrapper.cs: This file resides in App_Start

public class Bootstrapper
    {
        private static CompositionContainer compositionContainer;
        private static bool IsLoaded = false;

        public static CompositionContainer Container
        {
            get { return compositionContainer; }
            set { compositionContainer = value; }
        }

        public static void Compose(List<string> pluginFolders)
        {
            if (IsLoaded) return;
            var catalog = new AggregateCatalog();
            catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
            catalog.Catalogs.Add(new DirectoryCatalog(CommonUtility.GetApplicationDirectory()));
            compositionContainer = new CompositionContainer(catalog);
            compositionContainer.ComposeParts();
            IsLoaded = true;
        }

        public static T GetInstance<T>(string contractName = null)
        {
            var type = default(T);
            if (compositionContainer == null) return type;
            if (!string.IsNullOrWhiteSpace(contractName))
                type = compositionContainer.GetExportedValue<T>(contractName);
            else
                type = compositionContainer.GetExportedValue<T>();
            return type;
        }
    }

CommonUtility.cs: This file resides in App_Start

public class CommonUtility
    {

        public static string GetApplicationDirectory()
        {
            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
            UriBuilder uri = new UriBuilder(codeBase);
            string path = Uri.UnescapeDataString(uri.Path);
            return Path.GetDirectoryName(path);

        }
    }

HomeController.cs:

[CommonExceptionFilter]
  public class HomeController : Controller
  {
    private IConfigurationManager _configurationManager;

    [ImportingConstructor]
    public HomeController()
    {
      _configurationManager = Bootstrapper.GetInstance<IConfigurationManager>();
    }

    public async Task<ActionResult> Index()
    {
      //Business Logic
      return View()

    }
  }

IConfigurationManager.cs

[InheritedExport]
    public interface IConfigurationManager
    {
        string GetConfigurationValue(string keyName)
    }

ConfigurationManager.cs

[PartCreationPolicy(CreationPolicy.Shared)]
    public class ConfigurationManager: IConfigurationManager
    {
        [ImportingConstructor]
        public ConfigurationManager()
        {

        }

        public string GetConfigurationValue(string keyName)
        {
            return "";
        }
    }

IHttpHandlers Used In The MVC Project:

public class CommonServiceHandler : HttpTaskAsyncHandler, IRequiresSessionState
  {
    private ICommonServiceHandlerManager _commonServiceHandlerManager;


    public CommonServiceHandler()
    {
      _commonServiceHandlerManager = Bootstrapper.GetInstance<ICommonServiceHandlerManager>();
    }


    public override bool IsReusable
    {
      get
      {
        return false;
      }
    }

  }

Answer 1

This error indicates that at least one controller exists that its constructor parameters are not resolved.
Every controller needs a constructor to be resolved at run-time. By default every c# class has a default (parameter-less) constructor that can be called when an instance of the class is needed to be created.
However, after defining an explicit constructor, you lose the default constructor, therefore, you need to make sure that all your controllers have either a parameter-less constructor or if instead they have a parametric constructor the parameters need to be registered through dependency injection.