ASP.NET MVC: nessun costruttore senza parametri definito per questo oggetto

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

Stavo seguendo il libro " Pro ASP.NET MVC Framework " di Steven Sanderson . A pagina 132, in conformità con la raccomandazione dell'autore, ho scaricato l'assembly ASP.NET MVC Futures e l'ho aggiunto al mio progetto MVC. [Nota: questa potrebbe essere un'aringa rossa.]

Dopo questo, non potevo più caricare il mio progetto. L'errore precedente mi ha fermato a freddo.

La mia domanda non è "Potresti aiutarmi a correggere il mio codice?"

Invece, vorrei sapere più in generale:

• Come devo risolvere questo problema?
• Cosa dovrei cercare?
• Quale potrebbe essere la causa principale?

Sembra che dovrei capire il routing e i controller a un livello più profondo di quello che faccio ora.

Ho appena avuto un problema simile. La stessa eccezione si verifica quando a Modelnon ha un costruttore senza parametri.

Lo stack di chiamate stava calcolando un metodo responsabile della creazione di una nuova istanza di un modello.

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

Ecco un esempio:

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

Ciò può essere causato anche se il tuo modello utilizza un SelectList, poiché non ha un costruttore senza parametri :

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

Dovrai riformattare il tuo modello per farlo in modo diverso se questa è la causa. Quindi, usando IEnumerable<Contact>e scrivendo un metodo di estensione che crea l'elenco a discesa con le diverse definizioni di proprietà:

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

Oppure puoi usare l'approccio @Mark e @krilovich, devi solo sostituire SelectList in IEnumerable, funziona anche con MultiSelectList.

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

È necessario che l'azione corrispondente al controller non abbia un parametro.

Sembra che per la combinazione controller / azione che hai:

public ActionResult Action(int parameter)
{

}

ma hai bisogno

public ActionResult Action()
{

}

Inoltre, controlla il debugger delle rotte di Phil Haack per risolvere i problemi delle rotte.

Per impostazione predefinita, i controller MVC richiedono un costruttore predefinito senza parametri. Il più semplice sarebbe creare un costruttore predefinito che chiama quello con parametri:

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

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

Tuttavia, è possibile ignorare questa funzionalità ruotando la propria ControllerFactory. In questo modo è possibile indicare a MVC che durante la creazione di MyControllerun'istanza di Helper.

Ciò consente di utilizzare i framework di Iniezione delle dipendenze con MVC e di disaccoppiare davvero tutto. Un buon esempio di questo è finito sul sito web StructureMap . L'intero avvio rapido è buono e diventa specifico per MVC verso il basso in "Auto Wiring".

Questo errore si verifica anche quando si utilizza un IDependencyResolver , ad esempio quando si utilizza un contenitore IoC e il risolutore di dipendenze restituisce null. In questo caso ASP.NET MVC 3 utilizza per impostazione predefinita DefaultControllerActivator per creare l'oggetto. Se l'oggetto che viene creato non ha un costruttore no-args pubblico, verrà generata un'eccezione ogni volta che il risolutore di dipendenze fornito ha restituito null.

Ecco una traccia dello stack:

[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

È possibile ottenere questa eccezione in molti punti diversi nel framework MVC (ad esempio, non è possibile creare il controller o non è possibile creare un modello per fornire quel controller).

L'unico modo semplice che ho trovato per diagnosticare questo problema è di sostituire MVC il più vicino possibile all'eccezione con il tuo codice. Quindi il codice si interromperà all'interno di Visual Studio quando si verifica questa eccezione e puoi leggere il Tipo che causa il problema dalla traccia dello stack.

Sembra un modo orribile per affrontare questo problema, ma è molto veloce e molto coerente.

Ad esempio, se questo errore si verifica all'interno di MVC DefaultModelBinder (che sarà possibile verificare controllando la traccia dello stack), sostituire DefaultModelBinder con questo codice:

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 aggiorna il tuo Global.asax.cs:

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

Ora la prossima volta che ottieni quell'eccezione, Visual Studio si fermerà all'interno della tua classe MyDefaultModelBinder e puoi controllare la proprietà "modelType" per vedere quale tipo ha causato il problema.

L'esempio sopra funziona solo quando si ottiene l'eccezione "Nessun costruttore senza parametri definito per questo oggetto" solo durante l'associazione del modello. Ma un codice simile può essere scritto per altri punti di estensione in MVC (ad es. Costruzione di controller).

Ho avuto lo stesso errore, il colpevole nel mio caso era il costruttore che non era né pubblico né privato .

Nessun costruttore senza parametri definito per questo oggetto.

Dettagli eccezione: System.MissingMethodException: nessun costruttore senza parametri definito per questo oggetto.

Codice di riproduzione: assicurarsi che il costruttore abbia pubblico prima di esso.

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

    public string name
    {
        get;
        set;
    }
}

Primo video su http://tekpub.com/conferences/mvcconf

47:10 minuti mostrano l'errore e mostrano come sovrascrivere ControllerFactory predefinito. Cioè per creare una fabbrica di controller di mappe di strutture.

Fondamentalmente, stai probabilmente cercando di implementare l'iniezione di dipendenza ??

Il problema è che dipende dall'interfaccia.

Ho avuto lo stesso errore quando:

Utilizzando un ModelView personalizzato, entrambe le azioni (GET e POST) stavano passando il ModelView che conteneva due oggetti:

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

E il POST accetta anche la stessa vista del modello:

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

Il problema era che la vista riceveva ModelView (erano necessarie sia informazioni sul prodotto che sull'elenco delle categorie), ma dopo l'invio restituiva solo l'oggetto Product, ma poiché l'aggiunta POST prevedeva un ProductModelView, passava un NULL ma il costruttore ProductModelView aveva solo bisogno di due parametri ( Prodotto, RootCategories), quindi ha cercato di trovare un altro costruttore senza parametri per questo caso NULL, quindi non riesce con "nessun parametro ..."

Pertanto, la correzione dell'aggiunta POST come segue risolve il problema:

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

Spero che questo possa aiutare qualcuno (ho trascorso quasi mezza giornata per scoprirlo!).

Lo stesso per me. Il mio problema è apparso perché ho dimenticato che la mia classe del modello di base ha già proprietà con il nome che è stato definito nella 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  { ... }

... e modello di elaborazione del controller:

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

Niente di speciale, vero? Ma poi definisco 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>

... che causa l'errore "Costruttore senza parametri" sulla richiesta POST.

Spero che aiuti.

Ho avuto un problema simile e fondamentalmente il punto è che ci sono alcuni argomenti nel metodo di azione che non sono stati forniti dal processo di Model Binding (e in altre parole, questi campi non sono stati inviati dalla pagina di invio).

Questo problema si presenterà anche se vengono forniti tutti gli argomenti tranne uno e anche se quello mancante è un tipo nullable.

Il problema potrebbe anche essere il risultato di un errore di battitura, in cui il nome dell'argomento e il nome del campo modulo non saranno identici.

La soluzione è 1) verificare che i nomi corrispondano 2) fornire un valore predefinito per l'argomento 3) o fornire un altro metodo di azione senza questo argomento.

Ho avuto anche questo problema e ho pensato di condividere perché non riesco a trovare il mio problema sopra.

Questo era il mio codice

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

Chiamando questo ActionResult:

public ActionResult Overview(int id)

Ho pensato che sarebbe abbastanza intelligente da capire che il valore che passo è il parametro id per la panoramica, ma non lo è. Questo risolto:

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

Ho avuto la stessa eccezione a causa del fatto che non esisteva un regolatore pubblico senza parametri

Il codice era così:

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

cambiato in

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

problema risolto per me.

Tutte le risposte dicono di creare un parametro meno costruttore che non è l'ideale se non si desidera che altri sviluppatori lo utilizzino e solo il raccoglitore di modelli.

L'attributo [Obsolete("For model binding only", true)]sopra un costruttore pubblico genererà un errore del compilatore se un altro sviluppatore tenta di utilizzarlo. Mi ci sono voluti anni per trovarlo, spero che aiuti qualcuno.

Ho ricevuto questo errore. Stavo usando le interfacce nel mio costruttore e il mio risolutore di dipendenze non era in grado di risolvere, quando l'ho registrato, l'errore è scomparso.

Ho avuto lo stesso problema...

Se stai usando un'interfaccia per disaccoppiare la tua connessione con il tuo DbContext (come me) puoi usare structuremap.mvc (pacchetto 3 o 4 - nudget ) per poter usare una struttura nella tua classe controller. Questo ti darà una cartella DependencyResolution. Basta cambiare la riga commentata con For <InterfaceClass> () e utilizzare <DbContextClass> ().

Mentre questo può essere ovvio per alcuni, il colpevole di questo errore per me era il mio metodo MVC era vincolante per un modello che conteneva una proprietà di tipo Tuple<>. Tuple<>non ha un costruttore senza parametri.

Ho avuto lo stesso problema, ma in seguito ho scoperto che l'aggiunta di una nuova interfaccia e la classe corrispondente richiedono che sia registrata nel modulo inizializzabile per l'iniezione delle dipendenze. Nel mio caso era all'interno del codice come segue:

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

}

Nel mio caso, la mia classe aveva l' [Serializable]attributo.

Devi avere un costruttore che non accetta parametri se la tua classe lo è [Serializable]

Questo errore è iniziato per me quando ho aggiunto un nuovo modo per creare un'istanza di una classe.

Esempio:

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

L'errore è stato risolto quando l'ho aggiunto quando ho apportato questa modifica, aggiungendo un costruttore senza parametri. Credo che il compilatore crei per impostazione predefinita un costruttore senza parametri, ma se aggiungi il tuo devi crearlo esplicitamente.

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

Avevo aggiunto a DropDownListal mio modulo, tuttavia nel mio caso non era (e non era previsto che fosse) inviato con il modulo poiché era al di fuori dei <form></form>tag:

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

Poiché il modello conteneva il campo solo per la visualizzazione, ciò causava anche l' No parameterless constructor defined for this objecterrore perché il campo non era stato inviato affatto.

In questo caso l'ho risolto aggiungendo un legame escluso:

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

Questo mi è successo e i risultati in questa pagina sono stati una buona risorsa che mi ha portato in molte direzioni, ma vorrei aggiungere un'altra possibilità:

Come indicato in altre risposte, la creazione di un costruttore con parametri rimuove il costruttore implicito senza parametri, quindi è necessario digitarlo esplicitamente.

Qual era il mio problema era che anche un costruttore con parametri predefiniti innescava questa eccezione.

Dà errori:

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

Lavori:

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

Molto probabilmente potresti avere un costruttore parametrizzato nel tuo controller e qualunque risolutore di dipendenze che stai usando non è in grado di risolvere correttamente la dipendenza. È necessario inserire un punto di interruzione in cui è scritto il metodo del risolutore di dipendenze e si otterrà l'errore esatto nell'eccezione interna.

Ho avuto lo stesso problema.

Rimosso HttpFileCollectionBase filesdall'argomento del metodo Post Action e aggiunto come HttpFileCollectionBase files = Request.Files;nel corpo del metodo.

Ho aggiunto un costruttore senza parametri al modello all'interno della cartella DOMAIN e il problema è stato risolto.

 public User()
        {

        }

Quindi ho ricevuto quel messaggio anche prima, quando faccio una chiamata Ajax. Quindi, ciò che sostanzialmente chiede è un costruttore in quella classe di modello che viene chiamato dal controllore, non ha alcun parametro.

Ecco un esempio

public class MyClass{

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

 }