ASP.NET MVC: nenhum construtor sem parâmetros definido para este objeto

Server Error in '/' Application.
--------------------------------------------------------------------------------

No parameterless constructor defined for this object. 
Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code. 

Exception Details: System.MissingMethodException: No parameterless constructor defined for this object.

Source Error: 


Line 16:             HttpContext.Current.RewritePath(Request.ApplicationPath, false);
Line 17:             IHttpHandler httpHandler = new MvcHttpHandler();
Line 18:             httpHandler.ProcessRequest(HttpContext.Current);
Line 19:             HttpContext.Current.RewritePath(originalPath, false);
Line 20:         }

Eu estava seguindo o livro ' Pro ASP.NET MVC Framework ' de Steven Sanderson . Na página 132, de acordo com a recomendação do autor, baixei o assembly ASP.NET MVC Futures e o adicionei ao meu projeto MVC. [Nota: isso pode ser um arenque vermelho.]

Depois disso, não consegui mais carregar meu projeto. O erro acima me interrompeu.

Minha pergunta não é : "Você poderia me ajudar a corrigir meu código?"

Em vez disso, gostaria de saber de maneira mais geral:

• Como devo solucionar esse problema?
• O que devo procurar?
• Qual pode ser a causa raiz?

Parece que eu deveria entender o roteamento e os controladores em um nível mais profundo do que agora.

Eu apenas tive um problema semelhante. A mesma exceção ocorre quando a Modelnão possui construtor sem parâmetros.

A pilha de chamadas estava imaginando um método responsável pela criação de uma nova instância de um modelo.

System.Web.Mvc.DefaultModelBinder. CreateModel (ControllerContext controllerContext, ModelBindingContext bindingContext, Tipo modelType)

Aqui está uma amostra:

public class MyController : Controller
{
    public ActionResult Action(MyModel model)
    {

    }
}

public class MyModel
{
    public MyModel(IHelper helper) // MVC cannot call that
    {
        // ...
    }

    public MyModel() // MVC can call that
    {
    }
}

Isso também pode ser causado se o seu modelo estiver usando um SelectList, pois não possui construtor sem parâmetros :

public class MyViewModel
{
    public SelectList Contacts { get;set; }
}

Você precisará refatorar seu modelo para fazê-lo de maneira diferente, se essa for a causa. Portanto, use IEnumerable<Contact>e escreva um método de extensão que crie a lista suspensa com as diferentes definições de propriedades:

public class MyViewModel
{
    public Contact SelectedContact { get;set; }
    public IEnumerable<Contact> Contacts { get;set; }
}

public static MvcHtmlString DropDownListForContacts(this HtmlHelper helper, IEnumerable<Contact> contacts, string name, Contact selectedContact)
{
    // Create a List<SelectListItem>, populate it, return DropDownList(..)
}

Ou você pode usar a abordagem @Mark e @krilovich, basta substituir SelectList por IEnumerable, pois também funciona com o MultiSelectList.

 public class MyViewModel
    {
        public Contact SelectedContact { get;set; }
        public IEnumerable<SelectListItem> Contacts { get;set; }
    }

Você precisa que a ação que corresponde ao controlador não tenha um parâmetro.

Parece a combinação de controlador / ação que você possui:

public ActionResult Action(int parameter)
{

}

mas você precisa

public ActionResult Action()
{

}

Além disso, consulte o Debugger de rotas de Phil Haack para solucionar problemas de rotas.

Por padrão, os Controladores MVC requerem um construtor padrão sem parâmetros. O mais simples seria criar um construtor padrão que chame aquele com parâmetros:

public MyController() : this(new Helper()) {
}

public MyController(IHelper helper) {
  this.helper = helper;
}

No entanto, você pode substituir essa funcionalidade rolando por conta própria ControllerFactory. Dessa forma, você pode dizer ao MVC que, ao criar um, MyControllerforneça uma instância de Helper.

Isso permite que você use as estruturas de injeção de dependência com o MVC e realmente desacopla tudo. Um bom exemplo disso está no site do StructureMap . Todo o início rápido é bom, e ele é específico do MVC na parte inferior em "Instalação automática".

Este erro também ocorre ao usar um IDependencyResolver , como ao usar um contêiner de IoC, e o resolvedor de dependência retorna nulo. Nesse caso, o ASP.NET MVC 3 usa como padrão o DefaultControllerActivator para criar o objeto. Se o objeto que está sendo criado não tiver um construtor público no-args, uma exceção será lançada sempre que o resolvedor de dependência fornecido retornar nulo.

Aqui está um desses rastreamentos de pilha:

[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) +98
   System.RuntimeType.CreateInstanceDefaultCtor(Boolean publicOnly, Boolean skipVisibilityChecks, Boolean skipCheckThis, Boolean fillCache) +241
   System.Activator.CreateInstance(Type type, Boolean nonPublic) +69
   System.Web.Mvc.DefaultControllerActivator.Create(RequestContext requestContext, Type controllerType) +67

[InvalidOperationException: An error occurred when trying to create a controller of type 'My.Namespace.MyController'. Make sure that the controller has a parameterless public constructor.]
   System.Web.Mvc.DefaultControllerActivator.Create(RequestContext requestContext, Type controllerType) +182
   System.Web.Mvc.DefaultControllerFactory.GetControllerInstance(RequestContext requestContext, Type controllerType) +80
   System.Web.Mvc.DefaultControllerFactory.CreateController(RequestContext requestContext, String controllerName) +74
   System.Web.Mvc.MvcHandler.ProcessRequestInit(HttpContextBase httpContext, IController& controller, IControllerFactory& factory) +232
   System.Web.Mvc.<>c__DisplayClass6.<BeginProcessRequest>b__2() +49
   System.Web.Mvc.<>c__DisplayClassb`1.<ProcessInApplicationTrust>b__a() +13
   System.Web.Mvc.SecurityUtil.<GetCallInAppTrustThunk>b__0(Action f) +7
   System.Web.Mvc.SecurityUtil.ProcessInApplicationTrust(Action action) +22
   System.Web.Mvc.SecurityUtil.ProcessInApplicationTrust(Func`1 func) +124
   System.Web.Mvc.MvcHandler.BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, Object state) +98
   System.Web.Mvc.MvcHandler.BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, Object state) +50
   System.Web.Mvc.MvcHandler.System.Web.IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData) +16
   System.Web.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +8963444
   System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously) +184

Você pode obter essa exceção em muitos locais diferentes na estrutura MVC (por exemplo, ele não pode criar o controlador ou não pode criar um modelo para fornecer esse controlador).

A única maneira fácil que encontrei para diagnosticar esse problema é substituir o MVC o mais próximo possível da exceção pelo seu próprio código. Em seguida, seu código será interrompido no Visual Studio quando essa exceção ocorrer e você poderá ler o Tipo que está causando o problema no rastreamento de pilha.

Parece uma maneira horrível de abordar esse problema, mas é muito rápido e muito consistente.

Por exemplo, se este erro ocorrer dentro do MVC DefaultModelBinder (que você saberá verificando o rastreamento da pilha), substitua o DefaultModelBinder por este código:

public class MyDefaultModelBinder : System.Web.Mvc.DefaultModelBinder
{
    protected override object CreateModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType)
    {
        return base.CreateModel(controllerContext, bindingContext, modelType);
    }
}

E atualize seu Global.asax.cs:

public class MvcApplication : System.Web.HttpApplication
{
...
    protected void Application_Start(object sender, EventArgs e)
    {
        ModelBinders.Binders.DefaultBinder = new MyDefaultModelBinder();
    }
}

Agora, da próxima vez que você receber essa exceção, o Visual Studio irá parar dentro da classe MyDefaultModelBinder e você poderá verificar a propriedade "modelType" para ver qual tipo causou o problema.

O exemplo acima funciona para quando você obtém a exceção "Nenhum construtor sem parâmetros definido para este objeto" apenas durante a ligação do modelo. Mas código semelhante pode ser escrito para outros pontos de extensão no MVC (por exemplo, construção do controlador).

Eu recebi o mesmo erro, o culpado no meu caso foi o construtor que não era público nem privado .

Nenhum construtor sem parâmetros definido para este objeto.

Detalhes da exceção: System.MissingMethodException: nenhum construtor sem parâmetros definido para este objeto.

Código de reprodução: verifique se o construtor tem público antes dele.

public class Chuchi()
{
     Chuchi()    // The problem is this line. Public is missing
     {
         // initialization
         name="Tom Hanks";
     }

    public string name
    {
        get;
        set;
    }
}

Primeiro vídeo em http://tekpub.com/conferences/mvcconf

47:10 minutos em mostram o erro e mostram como substituir o ControllerFactory padrão. Ou seja, para criar fábrica de controlador de mapa de estrutura.

Basicamente, você provavelmente está tentando implementar injeção de dependência?

O problema é que é a dependência da interface.

Eu recebi o mesmo erro quando:

Usando um ModelView personalizado, ambas as Ações (GET e POST) estavam passando o ModelView que continha dois objetos:

public ActionResult Add(int? categoryID)
{
    ...
    ProductViewModel productViewModel = new ProductViewModel(
            product,
            rootCategories
            );
    return View(productViewModel); 
}

E o POST também aceita a mesma visualização de modelo:

[HttpPost]
[ValidateInput(false)]
public ActionResult Add(ProductModelView productModelView)
{...}

O problema foi que a View recebeu o ModelView (precisava do produto e da lista de informações de categorias), mas após o envio estava retornando apenas o objeto Product, mas como o POST Add esperado, um ProductModelView passou um NULL, mas o construtor ProductModelView precisou de dois parâmetros ( Product, RootCategories), depois tentou encontrar outro construtor sem parâmetros para esse caso NULL e falhou com "sem parâmetros ..."

Portanto, a correção do POST Add da seguinte maneira corrige o problema:

[HttpPost]
[ValidateInput(false)]
public ActionResult Add(Product product)
{...}

Espero que isso possa ajudar alguém (passei quase meio dia para descobrir isso!).

O mesmo para mim. Meu problema apareceu porque eu esqueci que minha classe de modelo base já tem propriedade com o nome que foi definido na exibição .

public class CTX : DbContext {  // context with domain models
    public DbSet<Products> Products { get; set; }  // "Products" is the source property
    public CTX() : base("Entities") {}
}

public class BaseModel : CTX { ... }
public class ProductModel : BaseModel { ... }
public class OrderIndexModel : OrderModel  { ... }

... e modelo de processamento do controlador:

[HttpPost]
[ValidateInput(false)]
public ActionResult Index(OrderIndexModel order) { ... }

Nada de especial, certo? Mas então eu defino a visão ...

<div class="dataItem">
    <%=Html.Label("Products")%>
    <%=Html.Hidden("Products", Model.index)%>   // I FORGOT THAT I ALREADY HAVE PROPERTY CALLED "Products"
    <%=Html.DropDownList("ProductList", Model.products)%>
    <%=Html.ActionLink("Delete", "D")%>
</div>

... que causa o erro "Construtor sem parâmetros" na solicitação POST.

Espero que ajude.

Eu tive um problema semelhante e, basicamente, o ponto é que existem alguns argumentos no método de ação que não foram fornecidos pelo processo de Model Binding (por outras palavras, esses campos não foram enviados pela página de envio).

Esse problema será exibido mesmo se todos os argumentos, exceto um, forem fornecidos e mesmo se o que estiver faltando for do tipo anulável.

O problema também pode ser resultado de um erro de digitação, no qual o nome do argumento e o nome do campo do formulário não serão idênticos.

A solução é 1) verificar se os nomes correspondem 2) fornecer um valor padrão para o argumento 3) ou fornecer outro método de ação sem esse argumento.

Eu também tive esse problema e pensei em compartilhar, pois não consigo encontrar meu problema acima.

Este foi o meu código

return RedirectToAction("Overview", model.Id);

Chamando este ActionResult:

public ActionResult Overview(int id)

Presumi que seria inteligente o suficiente descobrir que o valor que passo é o parâmetro de identificação da Visão geral, mas não é. Isso corrigiu:

return RedirectToAction("Overview", new {id = model.Id});

Recebi a mesma exceção, porque não havia empreiteiro público sem parâmetros

O código era assim:

public class HomeController : Controller
{        
    private HomeController()
    {
        _repo = new Repository();
    }

alterado para

 public class HomeController : Controller
{        
    public HomeController()
    {
        _repo = new Repository();
    }

problema resolvido para mim.

Todas as respostas dizem para criar um parâmetro menos construtor, o que não é ideal se você não quiser que outros desenvolvedores o usem e apenas o fichário do modelo.

O atributo [Obsolete("For model binding only", true)]acima de um construtor público lançará um erro de compilador se outro desenvolvedor tentar usar isso. Levei anos para encontrar isso, espero que ajude alguém.

Eu recebi esse erro. Eu estava usando interfaces no meu construtor e meu resolvedor de dependências não conseguiu resolver, quando eu o registrei, o erro desapareceu.

Eu tive o mesmo problema...

Se você estiver usando uma interface para desacoplar sua conexão com o DbContext (como eu), poderá usar o structuremap.mvc (pacote de 3 ou 4 nudget ) para poder usar uma estrutura na sua classe de controlador. Isso fornecerá uma pasta DependencyResolution. Apenas altere a linha comentada com For <InterfaceClass> () e use <DbContextClass> ().

Embora isso possa ser óbvio para alguns, o culpado desse erro para mim foi o método MVC que estava vinculando a um modelo que continha uma propriedade do tipo Tuple<>. Tuple<>não possui construtor sem parâmetros.

Eu tive o mesmo problema, mas mais tarde encontrei a adição de qualquer nova interface e a classe correspondente exige que ela seja registrada no Módulo Inicializável para injeção de dependência. No meu caso, estava dentro do código da seguinte maneira:

[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public class DependencyResolverInitialization : IConfigurableModule
{

    public void ConfigureContainer(ServiceConfigurationContext context)
    {
        context.Container.Configure(ConfigureContainer);
        var structureMapDependencyResolver = new StructureMapDependencyResolver(context.Container);
        DependencyResolver.SetResolver(structureMapDependencyResolver);
        GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerActivator), structureMapDependencyResolver);
    }

    private void ConfigureContainer(ConfigurationExpression container)
    {
        container.For<IAppSettingService>().Use<AppSettingService>();
        container.For<ISiteSettingService>().Use<SiteSettingService>();
        container.For<IBreadcrumbBuilder>().Use<BreadcrumbBuilder>();
        container.For<IFilterContentService>().Use<FilterContentService>().Singleton();
        container.For<IDependecyFactoryResolver>().Use<DependecyFactoryResolver>();
        container.For<IUserService>().Use<UserService>();
        container.For<IGalleryVmFactory>().Use<GalleryVmFactory>();
        container.For<ILanguageService>().Use<LanguageService>();
        container.For<ILanguageBranchRepository>().Use<LanguageBranchRepository>();
        container.For<ICacheService>().Use<CacheService>(); 
        container.For<ISearchService>().Use<SearchService>();
        container.For<IReflectionService>().Use<ReflectionService>();
        container.For<ILocalizationService>().Use<LocalizationService>();
        container.For<IBookingFormService>().Use<BookingFormService>();
        container.For<IGeoService>().Use<GeoService>();
        container.For<ILocationService>().Use<LocationService>();
        RegisterEnterpriseAPIClient(container);
    }

   public void Initialize(InitializationEngine context)
    {
    }

    public void Uninitialize(InitializationEngine context)
    {
    }

    public void Preload(string[] parameters)
    {
    }
}

}

No meu caso, minha classe tinha o [Serializable]atributo

Você é obrigado a ter um construtor que não aceita parâmetros se sua classe é [Serializable]

Este erro começou para mim quando adicionei uma nova maneira de instanciar uma classe.

Exemplo:

    public class myClass
    {
         public string id{ get; set; }
         public List<string> myList{get; set;}

         // error happened after I added this
         public myClass(string id, List<string> lst)
         {
             this.id= id;
             this.myList= lst;
         }
     }

O erro foi resolvido quando eu adicionei quando fiz essa alteração, adicionando um construtor sem parâmetros. Acredito que o compilador crie um construtor sem parâmetros por padrão, mas se você adicionar o seu próprio, deverá explicitamente criá-lo.

    public class myClass
    {
         public string id{ get; set; }
         public List<string> myList{get; set;}

         // error doesn't happen when I add this
         public myClass() { }

         // error happened after I added this, but no longer happens after adding above
         public myClass(string id, List<string> lst)
         {
             this.id= id;
             this.myList= lst;
         }
     }

Eu adicionei um DropDownListao meu formulário, no entanto, no meu caso, ele não foi (e não deveria ser) enviado com o formulário, pois estava fora das <form></form>tags:

@Html.DropDownList("myField", Model.MyField)

Como o Modelo continha o campo apenas para exibição, isso também causou o No parameterless constructor defined for this objecterro porque o campo não foi enviado.

Nesse caso, eu o corrigi adicionando uma ligação de exclusão:

public ActionResult Foo(int id, int? page, [Bind(Exclude = "MyField")]MyModel model)

Isso aconteceu comigo, e os resultados desta página foram um bom recurso que me levou a várias direções, mas eu gostaria de acrescentar outra possibilidade:

Conforme declarado em outras respostas, a criação de um construtor com parâmetros remove o construtor implícito sem parâmetros, portanto você deve digitá-lo explicitamente.

Qual foi o meu problema foi que um construtor com parâmetros padrão também acionou essa exceção.

Dá erros:

public CustomerWrapper(CustomerDto customer = null){...}

Trabalho:

public CustomerWrapper(CustomerDto customer){...}
public CustomerWrapper():this(null){}

Muito provavelmente você pode ter parametrizado o construtor em seu controlador e qualquer resolvedor de dependência que esteja usando não poderá resolver a dependência adequadamente. Você precisa colocar o ponto de interrupção em que o método do resolvedor de dependência é gravado e obterá o erro exato na exceção interna.

Eu tive o mesmo problema.

Apenas removido HttpFileCollectionBase filesdo argumento do método Post Action e adicionado como HttpFileCollectionBase files = Request.Files;no corpo do método.

Adicionei um construtor sem parâmetros ao modelo dentro da pasta DOMAIN e o problema foi resolvido.

 public User()
        {

        }

Então, já recebi essa mensagem antes, ao fazer uma chamada ajax. Então, o que basicamente está pedindo é que um construtor nessa classe de modelo que está sendo chamado pelo contoller não possua nenhum parâmetro.

Aqui está um exemplo

public class MyClass{

     public MyClass(){} // so here would be your parameterless constructor

 }