Solution

As @iuristona had said, the problem was that my IoC container was not able to resolve the dependency of the builder on my Controller.

Investigating I discovered the problem, follow the Ninject module code:

public class ModuloDomainCommon : NinjectModule
    {
        public override void Load()
        {
            Bind(typeof(IServiceBase<>)).To(typeof(ServiceBase<>));
            Bind<ILoginService>().To<LoginService>();

            Bind(typeof(IRepositoryBase<>)).To(typeof(RepositoryBase<>));
            Bind<ILoginRepository>().To<LoginRepository>();

        }
    }

It occurred that I had not put typeof in my generic dependencies as IServiceBase and IRepositoryBase . If you do not do this the compiler can not find the type of the generic classes and consequently the IoC container can not resolve the dependency. After adding typeof I did the following:

IoC Class

Here is where I read the Ninject modules.

public class IoC
    {
        public IoC()
        {
            Kernel = new StandardKernel(
                new ModuloDomainCommon();

            ServiceLocator.SetLocatorProvider(() => new NinjectServiceLocator(Kernel));
        }

        public IKernel Kernel { get; private set; }
    }

MyDependencyResolver class

Here is my class that extends the IDependencyResolver, and where I call the IoC class that contains the Ninject modules.

public class MyDependencyResolver : IDependencyResolver
    {
        private readonly IKernel _kernel;
        public MyDependencyResolver()
        {
            var ioc = new IoC();
            _kernel = ioc.Kernel;
        }

    #region IDependencyResolver Members
        public object GetService(Type serviceType)
        {
            return _kernel.TryGet(serviceType);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _kernel.GetAll(serviceType);
        }
    #endregion
}

Global.asax

Here is the call of the SetResolver of the DependencyResolver for my MyDependencyResolver class that is in a separate project. So I was able to isolate my Dependency Injection layer in an infrastructure project separate from my presentation layer.

protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            DependencyResolver.SetResolver(new MyApp.Infraestrutura.IoC.MyDependencyResolver());
}

Well, this error occurs because your IoC container is not being able to resolve the dependency in the constructor of your Controller , whereas the MVC does not find a version of the constructor without parameters.

I do not know if you will be able to implement your IoC pro MVC in an external project, since you need to implement the IDependencyResolver interface that is part of System.Web.Mvc .

Follow my version using ninject "pure":

public class NinjectDependencyResolver : IDependencyResolver
    {
        private IKernel _kernel;

        public NinjectDependencyResolver()
        {
            _kernel = new StandardKernel();

            RegisterServices(_kernel);
        }

        public NinjectDependencyResolver(IKernel kernel)
        {
            _kernel = kernel;
        }

        public object GetService(Type serviceType)
        {
            return _kernel.TryGet(serviceType);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _kernel.GetAll(serviceType);
        }

        public static void RegisterServices(IKernel kernel)
        {    

            // configure aqui seus serviços
            // kernel.Bind<InterfaceType>().To<ConcreteType>();
            kernel.Bind<DbContext>().To<MyDbContext>();//.WithConstructorArgument("nameOrConnectionString", "CpsConnectionString");
        }
    }