ASP.NET MVC: no hay un constructor sin 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:         }

Estaba siguiendo el libro de Steven Sanderson ' Pro ASP.NET MVC Framework '. En la página 132, de acuerdo con la recomendación del autor, descargué el ensamblaje de ASP.NET MVC Futures y lo agregué a mi proyecto MVC. [Nota: Esto podría ser un arenque rojo.]

Después de esto, ya no podía cargar mi proyecto. El error anterior me detuvo en frío.

Mi pregunta no es , "¿Podrías ayudarme a arreglar mi código?"

En cambio, me gustaría saber más en general:

• ¿Cómo debo solucionar este problema?
• ¿Qué debería estar buscando?
• ¿Cuál podría ser la causa raíz?

Parece que debería entender el enrutamiento y los controladores a un nivel más profundo que ahora.

Acabo de tener un problema similar. La misma excepción ocurre cuando a Modelno tiene un constructor sin parámetros.

La pila de llamadas estaba calculando un método responsable de crear una nueva instancia de un modelo.

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

Aquí hay una muestra:

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

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

Tendrá que refactorizar su modelo para hacerlo de otra manera si esta es la causa. Entonces, usando IEnumerable<Contact>y escribiendo un método de extensión que crea la lista desplegable con las diferentes definiciones de propiedades:

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 por IEnumerable, también funciona con MultiSelectList.

 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 de controlador / acción que tiene:

public ActionResult Action(int parameter)
{

}

pero tu necesitas

public ActionResult Action()
{

}

Además, consulte el Depurador de rutas de Phil Haack para solucionar problemas de rutas.

Por defecto, los controladores MVC requieren un constructor predeterminado sin parámetros. Lo más sencillo sería crear 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 haciendo rodar la suya ControllerFactory. De esta manera puede decirle a MVC que cuando está creando MyControlleruna instancia de Helper.

Esto le permite utilizar marcos de inyección de dependencia con MVC y realmente desacoplar todo. Un buen ejemplo de esto ha terminado en el sitio web de StructureMap . Todo el inicio rápido es bueno, y se vuelve específico para MVC en la parte inferior en "Auto Wiring".

Este error también ocurre cuando se usa un IDependencyResolver , como cuando se usa un contenedor IoC, y el solucionador de dependencias devuelve nulo. En este caso, ASP.NET MVC 3 usa de manera predeterminada el DefaultControllerActivator para crear el objeto. Si el objeto que se está creando no tiene un constructor público sin argumentos, se generará una excepción cada vez que el solucionador de dependencias devuelto sea nulo.

Aquí hay uno de esos rastros 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 marco 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 lo más cerca posible de la excepción con su propio código. Luego, su código se romperá dentro de Visual Studio cuando ocurra esta excepción, y puede leer el Tipo que causa el problema desde el seguimiento de la pila.

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

Por ejemplo, si se produce este error dentro de MVC DefaultModelBinder (que sabrá al verificar el seguimiento de la pila), reemplace 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 actualice 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ó el problema.

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

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

No hay un constructor sin parámetros definido para este objeto.

Detalles de la excepción: System.MissingMethodException: no hay un constructor sin parámetros definido para este objeto.

Código de reproducción: asegúrese de que el constructor tenga público antes.

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

    public string name
    {
        get;
        set;
    }
}

Primer video en http://tekpub.com/conferences/mvcconf

47:10 minutos muestra el error y muestra cómo anular el ControllerFactory predeterminado. Es decir, crear la estructura del controlador del mapa de fábrica.

Básicamente, ¿probablemente intentas implementar la inyección de dependencia?

El problema es que es la dependencia de la interfaz.

Recibí 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 la POST también acepta la misma vista de modelo:

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

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

Entonces, arreglando el POST Add de la siguiente manera corrige el problema:

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

Espero que esto pueda ayudar a alguien (¡pasé casi medio día para descubrirlo!).

Lo mismo para mi. Mi problema apareció porque olvidé que mi clase de modelo base ya tiene una 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>

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

Espero que 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 de modelo (y en otras palabras, estos campos no fueron enviados por la página de envío).

Este problema surgirá incluso si se proporcionan todos los argumentos menos uno, e incluso si el que falta es de tipo anulable.

El problema también podría 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é en compartirlo ya que no puedo encontrar mi problema arriba.

Este era mi código

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

Llamando a este ActionResult:

public ActionResult Overview(int id)

Supuse que sería lo suficientemente inteligente como para darse cuenta de que el valor que le paso es el parámetro id para Overview, pero no lo es. Esto lo solucionó:

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

Obtuve la misma excepción debido a que no había un constructor 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í.

Todas las respuestas dicen crear un constructor menos parámetros que no es ideal si no quieres que otros desarrolladores lo usen y solo el modelo de carpeta.

El atributo [Obsolete("For model binding only", true)]sobre un constructor público arrojará un error de compilación 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 pudo resolver, cuando lo registré, el error desapareció.

Yo tuve el mismo problema...

Si usa una interfaz para desacoplar su conexión con su DbContext (como yo), puede usar structuremap.mvc (paquete de 3 o 4 nudget ) para poder usar una estructura en su clase de controlador. Esto le dará una carpeta DependencyResolution. Simplemente cambie la línea comentada con su For <InterfaceClass> () y Use <DbContextClass> ().

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

Tuve el mismo problema, pero luego encontré que agregar una nueva interfaz y la clase correspondiente requiere que se registre en el Módulo Inicializable para la inyección de dependencia. 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)
    {
    }
}

}

En mi caso, mi clase tenía el [Serializable]atributo.

Debe tener un constructor que no tome parámetros si su clase es [Serializable]

Este error comenzó cuando agregué una nueva forma de crear una instancia de 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 constructor sin parámetros por defecto, pero si agrega el suyo, debe 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;
         }
     }

Agregué una DropDownLista mi formulario, sin embargo, en mi caso, no se envió (y no se pretendía) con el formulario ya que estaba fuera de las <form></form>etiquetas:

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

Como el Modelo contenía el campo solo para visualización, esto también causó el No parameterless constructor defined for this objecterror 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ó a mí, y los resultados en esta página fueron un buen recurso que me condujo en muchas direcciones, pero me gustaría agregar otra posibilidad:

Como se indicó en otras respuestas, la creación de un constructor con parámetros elimina el constructor implícito sin parámetros, por lo que debe escribirlo explícitamente.

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

Da errores:

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

Trabajos:

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

Yo tuve el mismo problema.

Solo se eliminó HttpFileCollectionBase filesdel argumento del método Post Action y se agregó como HttpFileCollectionBase files = Request.Files;en el cuerpo del método.

Agregué un constructor sin parámetros al modelo dentro de la carpeta DOMAIN, y el problema está resuelto.

 public User()
        {

        }

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

Aquí hay un ejemplo

public class MyClass{

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

 }