2

I have a complex object that I'm binding off of a form. The model binder looks like this:

public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
    var form = new MyForm();

    var myObject = ...; //try to load up the object

    /* logic to populate values on myObject */
    form.MyObject = myObject;

    bindingContext.ModelState.SetModelValue(bindingContext.ModelName, new ValueProviderResult(form, "", CultureInfo.CurrentUICulture));
    return form;
}

and it is doing what it's supposed to; I get a correctly populated MyForm out of it, and a reference to the same MyForm instance is included in the ModelState. However, the form does not get validated using either the DataAnnotations or my CustomValidation validation. In order to cause that validation, I have to add a TryValidateModel() call in my Controller:

[HttpPost]
public ActionResult ProcessMyForm(MyForm form)
{
    //ModelState has the MyForm instance inside of it
    //TryValidateModel(ModelState); //this does not work
    TryValidateModel(form); //this works
    if (!ModelState.IsValid)
    {
        return View("Complete", form);
    }
    return RedirectToAction("Index");
}

Which not only calls into my custom validation, but also updates the value of ModelState.IsValid.

In addition to my title question, this raises a couple of questions:

  1. Why does TryValidateModel(ModelState) not validate the form when ModelState has a reference to the same instance of the form that TryValidateModel(form) correctly validates?

  2. Why does TryValidateModel(form) cause the value of ModelState.IsValid to be updated?

  3. In general, why are the binders responsible for updating ModelState?

Matt Mills
  • 8,692
  • 6
  • 40
  • 64

1 Answers1

1

The ModelBinder's responsibility is to bind values from the request into the model(s) you are using.

The ModelState property is just a dictionary containing the current state of you models. Look at modelstate like an errorlist.

When you have a custom ModelBinder you map the values from the request into the class of your choice. That will end up as a parameter into your actionmethod.

I wouldn't agree with you that modelbinders are responsible for updating the ModelState since the ModelBinder is run when it binds the values, it can still have IsValid=true before you run TryValidateModel.

When you later run the TryValidateModel (or ValidateModel for that matter) it will update the ModelState property with whatever errors you have. You can also use different types to validation methods (DataAnnotations, IValidatableObject...)

Jonas Cannehag
  • 391
  • 2
  • 11
  • Thanks for your reply. I have to disagree with a number of your points though. Firstly, it's true that the `ModelBinder` is not required to populate the `ModelState` object. However, my experience has been that if the `ModelBinder` does not populate the `ModelState` object, then the bound model does not get included in validation. If there's a way to cause the request context to put the bound object into `ModelState`, that would probably be an answer to my title question. – Matt Mills Mar 11 '11 at 03:47
  • I realize that `TryValidateModel` or `ValidateModel` will update the `ModelState` with errors. My point was that the MVC runtime appears to call these methods (or something similar) **before** my custom model binder is given a chance to place its bound model in `ModelState`, and that requires me to call them explicitly, which feels to me like an incorrect order of operations. I would expect that the order of operations would be `receive request -> bind parameters to model -> validate model -> process request`, but in this case `validate model` is part of `process request`. – Matt Mills Mar 11 '11 at 03:54