ASP.NET MVC: Pas de constructeur sans paramètre défini pour cet objet

Cela peut aussi être causé si votre Modèle à l'aide d'un SelectList, que cela n'a pas de constructeur sans paramètre:

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

Vous aurez besoin de restructurer le modèle de le faire d'une autre façon, si c'est la cause. Donc, à l'aide d'un IEnumerable<Contact> et de l'écriture d'une méthode d'extension qui crée la liste déroulante avec les différentes définitions de propriété:

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 vous pouvez utiliser le @Mark et @krilovich approche, il faut juste remplacer SelectList à IEnumerable, il travaille avec MultiSelectList trop.

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

Par défaut, les Contrôleurs MVC besoin d'un constructeur par défaut sans paramètre. Le plus simple serait de faire un constructeur par défaut qui appelle celui avec les paramètres:

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

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

Toutefois, vous pouvez remplacer cette fonctionnalité par roulement de votre propre ControllerFactory. De cette façon, vous pouvez dire MVC que lorsque vous créez un MyController donner un exemple de Helper.

Cela vous permet d'utiliser l'Injection de Dépendance cadres avec MVC, et vraiment dissocier de tout. Un bon exemple de ce est au cours du StructureMap site web. L'ensemble de démarrage rapide est bonne, et il obtient spécifiques à MVC vers le bas "Auto Câblage".

Vous pouvez obtenir cette exception à de nombreux endroits différents dans le framework MVC (par exemple, il ne peut pas créer le contrôleur, ou il ne peut pas créer un modèle pour donner le contrôleur).

Le moyen le plus facile que j'ai trouvé pour diagnostiquer ce problème est de remplacer MVC comme proche de l'exception que possible avec votre propre code. Puis votre code de saut de ligne dans Visual Studio lorsque cette exception se produit, et vous pouvez lire le Type à l'origine du problème de la trace de la pile.

Cela semble être une horrible manière d'aborder ce problème, mais il est très rapide, et très cohérent.

Par exemple, si cette erreur se produit à l'intérieur de la MVC DefaultModelBinder (qui vous permettra de savoir en cochant la trace de la pile), puis remplacer le DefaultModelBinder avec ce code:

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

Et mise à jour de votre Global.asax.cs:

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

Maintenant, la prochaine fois que vous obtenez cette exception, Visual Studio va s'arrêter à l'intérieur de votre MyDefaultModelBinder classe, et vous pouvez cocher la case "modelType" bien de voir ce type ont causé le problème.

L'exemple ci-dessus fonctionne pour quand vous obtenez l' "Pas de constructeur sans paramètre défini pour cet objet" exception lors de la liaison de modèle, seulement. Mais le même code peut être écrit pour d'autres points d'extension MVC (par exemple, le contrôleur de la construction).

Première vidéo sur http://tekpub.com/conferences/mvcconf

47:10 minutes en montrer l'erreur et montre comment remplacer la valeur par défaut ControllerFactory.
I. e. pour créer la structure de la carte contrôleur de l'usine.

Fondamentalement, vous êtes probablement en train de mettre en œuvre l'injection de dépendance??

Le problème est que l'interface est la dépendance.

De même pour moi.
Mon problème est apparu, j'ai oublié que mon modèle de base de la classe a déjà bien avec le nom de qui a été défini dans la vue.

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

... le contrôleur et le modèle de traitement :

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

Rien de spécial, non? Mais puis-je définir la vue ...

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

... ce qui provoque le "constructeur sans paramètre" erreur sur la requête POST.

Espère que ça aide.

J'ai eu ce problème et j'ai pensé partager car je ne peux pas trouver mon problème ci-dessus.

C'était mon code

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

L'appel de cette ActionResult:

public ActionResult Overview(int id)

J'ai supposé qu'il serait assez intelligent pour comprendre que la valeur que je passe c'est l'id de paramètre pour une vue d'ensemble, mais il n'est pas. Ce corrigé:

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

J'ai eu le même problème...

Si vous utilisez une interface de dissocier votre connexion à l'encontre de votre DbContext (comme moi), vous pouvez utiliser structuremap.mvc (3 ou 4 nudget paquet) pour être en mesure d'utiliser un constructure dans votre contrôleur de classe. Cela vous donnera une DependencyResolution dossier. Il suffit de changer la ligne de commentaire avec votre Pour< InterfaceClass >() et d'Utiliser< DbContextClass >().

Toutes les réponses que dire de créer un des paramètres de moins de constructeur qui n'est pas idéal si vous ne voulez pas les autres développeurs de l'utiliser et que le modèle de classeur.

L'attribut [Obsolete("For model binding only", true)] au-dessus d'un constructeur public lèvera une erreur de compilation si un autre dev tente d'utiliser ce. M'a pris âges à trouver cet, espérons que cela aide quelqu'un.

Cette erreur a commencé pour moi quand j'ai ajouté une nouvelle façon d'instancier une classe.

Exemple:

    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'erreur a été résolu lorsque j'ai ajouté quand j'ai fait cette modification, l'ajout d'un constructeur sans paramètre. Je crois que le compilateur crée un sans paramètre constuctor par défaut, mais si vous ajoutez votre propre alors vous devez explicitement le créer.

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

Ce qui m'est arrivé, et les résultats sur cette page ont été une bonne ressource qui m'a conduit dans de nombreuses directions, mais je voudrais ajouter une autre possibilité:

Comme indiqué dans d'autres réponses, la création d'un constructeur avec paramètres supprime l'implicite constructeur sans paramètre, vous devez explicitement le type de l'.

Quel était mon problème était qu'un constructeur avec paramètres par défaut a également déclenché cette exception.

Donne des erreurs:

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

Travaux:

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

J'ai eu le même problème mais trouvé plus tard que l'ajout de toute nouvelle interface et correspondant de la classe nécessite d'être enregistré en vertu de Initializable Module pour l'injection de dépendances. Dans mon cas, c'était dans le code comme suit:

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

}

Dans mon cas, ma classe a eu la [Serializable] attribut.

Vous êtes tenus d'avoir un constructeur qui ne prend aucun paramètre si votre classe est [Serializable]