ASP.NET MVC: Ningún constructor sin parámetros definido para este objeto

Esto también puede ser causado si su Modelo está usando una lista de selección, ya que no tiene un constructor sin parámetros :

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

Necesitará refactorizar su modelo para hacerlo de una manera diferente si esta es la causa. Así que usando un IEnumerable<Contact> y escribiendo un método de extensión que crea la lista desplegable con las diferentes definiciones de propiedad:

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(..)
}

O puede usar el enfoque @Mark y @krilovich, solo necesita reemplazar SelectList aerableumerable, funciona con MultiSelectList demasiado.

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

Necesita la acción que corresponde al controlador para no tener un parámetro.

Parece que para la combinación controlador / acción tienes:

public ActionResult Action(int parameter)
{

}

Pero necesitas

public ActionResult Action()
{

}

Además, echa un vistazo al Depurador de rutas de Phil Haack para solucionar problemas de rutas.

De forma predeterminada, los controladores MVC requieren un constructor predeterminado sin parámetros. Lo más simple sería hacer un constructor predeterminado que llame al que tiene parámetros:

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

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

Sin embargo, puede anular esta funcionalidad rodando su propio ControllerFactory. De esta manera puedes decirle a MVC que cuando estás creando un MyController dale una instancia de Helper.

Esto le permite usar marcos de inyección de dependencias con MVC, y realmente desacoplar todo. Un buen ejemplo de esto es más en el sitio web StructureMap . Todo el quickstart es bueno, y se vuelve específico para MVC hacia la parte inferior en "Cableado automático".

Este error también ocurre cuando se usa un IDependencyResolver, como cuando se usa un contenedor IoC, y el solucionador de dependencias devuelve null. En este caso ASP.NET MVC 3 usa por defecto el DefaultController Activator para crear el objeto. Si el objeto que se está creando no tiene un constructor público no-args, se lanzará una excepción cada vez que el solucionador de dependencias proporcionado devuelva null.

Aquí hay una pista de pila:

[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

Puede obtener esta excepción en muchos lugares diferentes en el framework MVC (por ejemplo, no puede crear el controlador, o no puede crear un modelo para darle ese controlador).

La única manera fácil que he encontrado para diagnosticar este problema es anular MVC tan cerca de la excepción como sea posible con su propio código. Luego, su código se romperá dentro de Visual Studio cuando se produzca esta excepción, y podrá leer el Tipo que causa el problema desde el seguimiento de la pila.

Esto parece una manera horrible para abordar este problema, pero es muy rápido, y muy consistente.

Por ejemplo, si este error está ocurriendo dentro del MVC DefaultModelBinder (que sabrá comprobando el seguimiento de la pila), reemplace el DefaultModelBinder con 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);
    }
}

Y actualizar su Global.asax.cs:

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

Ahora, la próxima vez que obtenga esa excepción, Visual Studio se detendrá dentro de su clase MyDefaultModelBinder, y puede verificar la propiedad "ModelType" para ver qué tipo causó problema.

El ejemplo anterior funciona cuando se obtiene la excepción "Sin constructor sin parámetros definido para este objeto" solo durante el enlace del modelo. Pero código similar se puede escribir para otros puntos de extensión en MVC (por ejemplo, la construcción del controlador).

Obtuve el mismo error, el culpable en mi caso fue el constructor que no era ni público ni privado.

No se ha definido ningún constructor sin parámetros para este objeto.

Detalles de la excepción: Sistema.MissingMethodException: Ningún constructor sin parámetros definido para este objeto.

Código de reproducción: Asegúrese de que el constructor tiene public antes.

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

    public string name
    {
        get;
        set;
    }
}

Primer vídeo en http://tekpub.com/conferences/mvcconf

47:10 minutos en mostrar el error y muestra cómo sobreescribir el ControllerFactory predeterminado. Es decir, para crear una fábrica de controladores de mapas de estructura.

Básicamente, es probable que esté tratando de implementar la inyección de dependencia??

El problema es que es la dependencia de la interfaz.

Tengo el mismo error cuando:

Usando un ModelView personalizado, ambas Acciones (GET y POST) pasaban el ModelView que contenía dos objetos:

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

Y el POST también acepta la misma vista modelo:

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

El problema fue que la Vista recibió el ModelView (necesitaba información tanto del producto como de la lista de categorías), pero después de enviar solo devolvía el objeto Product, pero como el POST Add esperaba un ProductModelView pasó un NULL pero luego el ProductModelView solo constructor necesitaba dos parámetros (Product, RootCategories), luego trató de encontrar otro constructor sin parámetros para este caso NULO y luego falla con "no parameterles..."

Por lo tanto, la fijación de la ENTRADA Añadir de la siguiente manera corregir el problema:

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

Espero que esto pueda ayudar a alguien (Pasé casi medio día para averiguar esto!).

Lo mismo para mí. Mi problema apareció porque olvidé que mi clase de modelo base ya tiene la propiedad con el nombre que se definió en la vista.

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  { ... }

... y modelo de procesamiento del controlador:

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

Nada especial, ¿verdad? Pero luego defino la vista ...

<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>

... lo que causa el error "constructor sin parámetros" en la solicitud POST.

Espero que eso ayude.

Tuve un problema similar, y básicamente el punto es que hay algunos argumentos en el método de acción que no fueron proporcionados por el proceso de Enlace del Modelo, (y en otras palabras, estos campos no fueron enviados por la página de envío).

Este problema aparecerá incluso si se suministran todos los argumentos menos uno, e incluso si el que falta es un tipo nullable.

El problema también puede ser el resultado de un error tipográfico, en el que el nombre del argumento y el nombre del campo del formulario no serán idénticos.

La solución es 1) verificar que los nombres coincidan 2) proporcionar un valor predeterminado para el argumento 3) o proporcionar otro método de acción sin este argumento.

También tuve este problema y pensé que compartiría ya que no puedo encontrar mi problema anterior.

Este era mi código

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

Llamando a este ActionResult:

public ActionResult Overview(int id)

Asumí que sería lo suficientemente inteligente como para averiguar que el valor que le paso es el parámetro id para la vista general, pero no lo es. Esto lo arregló:

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

Tengo la misma excepción debido a que no había contructor público sin parámetros

El código era así:

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

Cambiado a

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

Problema resuelto para mí.

Yo tenía el mismo problema...

Si está usando una interfaz para desacoplar su conexión contra su DbContext (como yo) puede usar structuremap.mvc (3 o 4-nudget package ) para poder usar una constructure en su clase controller. Esto le dará una carpeta DependencyResolution. Simplemente cambie la línea comentada con su For () y use().

Si bien esto puede ser obvio para algunos, el culpable de este error para mí fue que mi método MVC se vinculaba a un modelo que contenía una propiedad de tipo Tuple<>. Tuple<> no tiene constructor sin parámetros.

Todas las respuestas dicen crear un constructor parameters less que no es ideal si no desea que otros desarrolladores lo usen y solo el binder del modelo.

El atributo [Obsolete("For model binding only", true)] sobre un constructor público lanzará un error de compilador si otro desarrollador intenta usar esto. Me llevó años encontrar esto, espero que ayude a alguien.

Tengo este error. Estaba usando interfaces en mi constructor y mi solucionador de dependencias no fue capaz de resolver, cuando lo registré, el error desapareció.

Este error comenzó para mí cuando agregué una nueva forma de instanciar una clase.

Ejemplo:

    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;
         }
     }

El error se resolvió cuando agregué cuando hice este cambio, agregando un constructor sin parámetros. Creo que el compilador crea un constuctor sin parámetros por defecto, pero si agregas el tuyo entonces debes crearlo explícitamente.

    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;
         }
     }

Yo había agregado un DropDownList a mi formulario, sin embargo en mi caso no fue (y no estaba destinado a ser) enviado con el formulario, ya que estaba fuera de las etiquetas <form></form>:

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

Como el Modelo contenía el campo solo para mostrar, esto también causó el error No parameterless constructor defined for this object porque el campo no se envió en absoluto.

En este caso lo arreglé agregando un enlace de exclusión:

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

Esto me sucedió, y los resultados en esta página fueron un buen recurso que me llevó en muchas direcciones, pero me gustaría agregar otra posibilidad:

Como se indica en otras respuestas, crear un constructor con parámetros elimina el constructor implícito sin parámetros, por lo que debe escribirlo explícitamente.

Mi problema era que un constructor con parámetros predeterminados también activaba esta excepción.

Da errores:

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

Funciona:

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

Lo más probable es que tenga un constructor parametrizado en su controlador y cualquier solucionador de dependencias que esté utilizando no es capaz de resolver la dependencia correctamente. Debe poner el punto de interrupción donde se escribe el método de resolución de dependencias y obtendrá el error exacto en la excepción interna.

Tuve el mismo problema, pero luego encontré que agregar cualquier interfaz nueva y la clase correspondiente requiere que se registre bajo el Módulo Inicializable para la inyección de dependencias. En mi caso estaba dentro del código de la siguiente manera:

[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)
    {
    }
}

}

Yo tenía el mismo problema.

Acaba de eliminar HttpFileCollectionBase files del argumento del método de acción Post y se añade como HttpFileCollectionBase files = Request.Files; en el cuerpo del método.

Así que he recibido ese mensaje antes también, al hacer una llamada ajax. Así que lo que básicamente está pidiendo es un constructor en esa clase de modelo que está siendo llamado por el contoller, no tiene ningún parámetro.

Aquí hay un ejemplo

public class MyClass{

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

 }