### Issue - Model Binder Order

This is, unfortunately, the standard behavior of [`Validator.TryValidateObject`][0] which

>  does not recursively validate the property values of the object

As pointed out in Jeff Handley's article on [Validating Object and Properties with the Validator][1], by default, the validator will validate in order:

1. Property-Level Attributes
2. Object-Level Attributes
3. Model-Level implementation `IValidatableObject`

The problem is, at each step of the way...

> If any validators are invalid, `Validator.ValidateObject` will abort validation and return the failure(s)

### Issue - Model Binder Fields

Another possible issue is that the model binder will only run validation on objects that it has decided to bind.  For example, if you don't provide inputs for fields within complex types on your model, the model binder won't need to check those properties at all because it hasn't called the constructor on those objects.  According to Brad Wilson's great article on [Input Validation vs. Model Validation in ASP.NET MVC][5]:

> The reason we don't "dive" into the Address object recursively is that there was nothing in the form that bound any values inside of Address.

### Solution - Validate Object at the same time as Properties

One way to solve this problem is to convert object-level validations to property level validation by adding a custom validation attribute to the property that will return with the validation result of the object itself.

Josh Carroll's article on [Recursive Validation Using DataAnnotations][3] provides an implementation of one such strategy (originally in [this SO question][4]).  If we want to validate a complex type (like Address), we can add a custom `ValidateObject` attribute to the property, so it is evaluated on the first step

    public class Person {
      [Required]
      public String Name { get; set; }
    
      [Required, ValidateObject]
      public Address Address { get; set; }
    }

You'll need to add the following **ValidateObjectAttribute** implementation:

    public class ValidateObjectAttribute: ValidationAttribute {
       protected override ValidationResult IsValid(object value, ValidationContext validationContext) {
          var results = new List<ValidationResult>();
          var context = new ValidationContext(value, null, null);
    
          Validator.TryValidateObject(value, context, results, true);
    
          if (results.Count != 0) {
             var compositeResults = new CompositeValidationResult(String.Format("Validation for {0} failed!", validationContext.DisplayName));
             results.ForEach(compositeResults.AddResult);
    
             return compositeResults;
          }
    
          return ValidationResult.Success;
       }
    }
    
    public class CompositeValidationResult: ValidationResult {
       private readonly List<ValidationResult> _results = new List<ValidationResult>();
    
       public IEnumerable<ValidationResult> Results {
          get {
             return _results;
          }
       }
    
       public CompositeValidationResult(string errorMessage) : base(errorMessage) {}
       public CompositeValidationResult(string errorMessage, IEnumerable<string> memberNames) : base(errorMessage, memberNames) {}
       protected CompositeValidationResult(ValidationResult validationResult) : base(validationResult) {}
    
       public void AddResult(ValidationResult validationResult) {
          _results.Add(validationResult);
       }
    }


### Solution - Validate Model at the Same time as Properties

For objects that implement `IValidatableObject`, when we check the ModelState, we can also check to see if the model itself is valid before returning the list of errors.  We can add any errors we want by calling <code>ModelState.AddModelError(*field*, *error*)</code>.  As specified in [How to force MVC to Validate IValidatableObject][6], we can do it like this:


    [HttpPost]
    public ActionResult Create(Model model) {
        if (!ModelState.IsValid) {
            var errors = model.Validate(new ValidationContext(model, null, null));
            foreach (var error in errors)                                 
                foreach (var memberName in error.MemberNames)
                    ModelState.AddModelError(memberName, error.ErrorMessage);
    
            return View(post);
        }
    }

> **Also**, if you want a more elegant solution, you can write the code once by providing your own custom model binder implementation in Application_Start() with `ModelBinderProviders.BinderProviders.Add(new CustomModelBinderProvider());`.  There are good implementations [here][7] and [here][8]

[0]: https://msdn.microsoft.com/en-us/library/dd411772.aspx
[1]: http://jeffhandley.com/archive/2009/10/16/validator.aspx
[2]: https://stackoverflow.com/a/8549741/1366033
[3]: http://www.technofattie.com/2011/10/05/recursive-validation-using-dataannotations.html
[4]: https://stackoverflow.com/a/7665862/1366033
[5]: http://bradwilson.typepad.com/blog/2010/01/input-validation-vs-model-validation-in-aspnet-mvc.html
[6]: https://stackoverflow.com/a/6431986/1366033
[7]: https://stackoverflow.com/a/7523993/1366033
[8]: http://www.haneycodes.net/trigger-ivalidatableobject-validate-when-modelstate-isvalid-is-false/

Can I automatically validate complex child objects when validating a parent object and include the results in the populated `ICollection<ValidationResult>`?

If I run the following code:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    
    namespace ConsoleApplication1
    {
        public class Person
        {
            [Required]
            public string Name { get; set; }
    
            public Address Address { get; set; }
        }
    
        public class Address
        {
            [Required]
            public string Street { get; set; }
    
            [Required]
            public string City { get; set; }
    
            [Required]
            public string State { get; set; }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Person person = new Person
                {
                    Name = null,
                    Address = new Address
                    {
                        Street = "123 Any St",
                        City = "New York",
                        State = null
                    }
                };
    
                var validationContext = new ValidationContext(person, null, null);
                var validationResults = new List<ValidationResult>();
    
                var isValid = Validator.TryValidateObject(person, validationContext, validationResults);
    
                Console.WriteLine(isValid);
    
                validationResults.ForEach(r => Console.WriteLine(r.ErrorMessage));
    
                Console.ReadKey(true);
            }
        }
    }

I get the following output:
> `False`  
> `The Name field is required.`

But I was expecting something similar to:
> `False`  
> `The Name field is required.`  
> `The State field is required.`

----

I offered a bounty for a better child object validation solution but didn't get any takers, ideally

 * validating child objects to an arbitrary depth
 * handling multiple errors per object
 * correctly identifying the validation errors on the child object fields.

I'm still surprised the framework doesn't support this.

How can I tell the Data Annotations validator to also validate complex child properties?

Can we make [Regex case-insensitive in *C#*][6]? : **Yes**

> Set option inline via [`(?i)` pattern construct][3] or via  [`RegexOptions.IgnoreCase`][4] param

Can we make [Regex case-insensitive in *JavaScript*][7]? : **Yes**

> Set flag via [<code><b>/</b><i>pattern</i><b>/</b><i>flags</i></code>][8] syntax or the insensitive flag `/REGEX/i`

(*Aside*) Can we make [Regex case-insensitive in *HTML5 Pattern Attribute*?][5] : **No**


As Chris R. Timmons points out on [`RegularExpressionValidator` doesn't ignore case][2]: 

> There is no property in the RegularExpressionValidator control that
allows regex options to be set.

> If your control does both client-side and server-side validation, **the
regex must use a subset of regular expression syntax that both
JS and .NET can execute**. In this case, to make a regex ignore
case it is necessary to use a character class construct like `[a-zA-Z]`
to match both upper and lower case characters.

> If your validation is done on the server-side only, you can use the
more powerful .NET regular expression syntax. In this case, you can
place the `(?i)` option at the beginning of the regex to tell it to
ignore case.

So, if you want to use the out of the box validator, you're stuck with Geoff's solution of using character sets like this: `[aA]`


[2]: https://www.thecodingforums.com/threads/regularexpressionvalidator-doesnt-ignore-case.79327/
[3]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference#regular-expression-options
[4]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options
[5]: https://stackoverflow.com/a/5525111/1366033
[6]: https://stackoverflow.com/a/2439976/1366033
[7]: https://stackoverflow.com/q/3939715/1366033
[8]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2

Given this regular expression: `"^[0-9]*\s*(lbs|kg|kgs)$"`  how do I make it case insensitive?  I am trying to use this in a .net regular expression validator, so I need to specify case insensitivity in the pattern.

**I can not use the RegexOptions programatically because I am specifying the regular expression in a RegularExpressionValidator**

Make regular expression case insensitive in ASP.NET RegularExpressionValidator

To expand on the link to [Scott Guthrie's article][5], starting with MVC 3, you can perform class level validation by implementing the [`IValidatableObject`][1] Interface.  

This will work inside the context of the current validation pipeline so it can be nested on as many custom classes and properties as you like and continue to return the full array of possible error messages.

For your class, ditch the class level attributes, and add a method called `Validate` like this:

    public class EditSiteUser : IValidatableObject
    {
        public int UserId { get; set; }

        [Required(ErrorMessage = "Du skal indtaste et brugernavn")]
        public string Username { get; set; }
    
        [Required(ErrorMessage = "Du skal indtaste en adgangskode")]
        public string Password { get; set; }

        [Required(ErrorMessage="Du skal bekræfte adgangskode")]
        public string PasswordConfirm { get; set; }
    
        [Required(ErrorMessage = "Du skal indtaste en e-mailadresse")]
        [Email(ErrorMessage = "Ugyldig e-mailadresse")]
        public string Email { get; set; }

        [Required(ErrorMessage="Du skal bekræfte e-mailadressen")]
        [Email(ErrorMessage="Ugyldig e-mailadresse")]
        public string EmailConfirm { get; set; }

    
        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        { 
          // put whatever class level validation you want here

          if (Email !== EmailConfirm)
          {
              yield return new ValidationResult("E-mailadresserne skal være ens", new[] {"EmailConfirm"})
          }

          if (Password !== PasswordConfirm)
          {
              yield return new ValidationResult("Adgangskoderne skal være ens", new[] {"PasswordConfirm"})
          }
        }

    }


You can continue to `yield return` as many validation messages as you'd like.

And you can display them all on the client with [`@Html.ValidationSummary`][3]

If you'd like the message to appear alongside a particular control, the [`ValidationResult`][2] constructor takes an overload with the `memberNames` of the affected properties, and you can provide the validation message for that particular property with the [`ValidationMessageFor`][4] HTML helper like this:

    @Html.ValidationMessageFor(Function(model) model.TestOne )

----

Also, it's worth mentioning that you can use the [**`CompareValidator`**][7] to easily ensure the values of two different properties are equal.  The upside to using this annotation is that it automatically knows how to enforce this on the client as well as the server, whereas adding `IValidatableObject` will only run on the server.

    [DataType(DataType.Password)]
    public string Password { get; set; }
 
    [Compare("Password")]
    [DataType(DataType.Password)]
    public string ConfirmPassword { get; set; }

---

For further reading, Scott Guthrie another post with more detail on [class level validation][6].

 
[1]: https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.ivalidatableobject%28v=vs.110%29.aspx
[2]: https://msdn.microsoft.com/en-us/library/dd411880(v=vs.110).aspx
[3]: https://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.validationsummary%28v=vs.110%29.aspx
[4]: https://msdn.microsoft.com/en-us/library/system.web.mvc.html.validationextensions.validationmessagefor%28v=vs.118%29.aspx
[5]: http://weblogs.asp.net/scottgu/introducing-asp-net-mvc-3-preview-1
[6]: http://weblogs.asp.net/scottgu/class-level-model-validation-with-ef-code-first-and-asp-net-mvc-3
[7]: https://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.comparevalidator(v=vs.110).aspx

**Update after Bounty was awarded**

A new solution is coming up to this problem. Please refer to ASP.NET MVC 3 Preview 1 here: http://weblogs.asp.net/scottgu/archive/2010/07/27/introducing-asp-net-mvc-3-preview-1.aspx

Look in the section **Model Validation Improvements**, where you will see the solution to my problem.


----------

**Original Post**

Referring to my earlier post https://stackoverflow.com/questions/2450198/how-to-validate-two-properties-with-asp-net-mvc-2 where I asked how I could compare two properties for Model validation.

I did find the answer useful, but I was left with an entirely different problem:

**Problem**: If a Property-level ValidationAttribute contains an error, then the Class-level ValidationAttributes are NOT validated.

Please consider the following:

    [EqualTo("Email", "EmailConfirm", ErrorMessage = "E-mailadresserne skal være ens")]
    [EqualTo("Password", "PasswordConfirm", ErrorMessage = "Adgangskoderne skal være ens")]
    [Bind(Exclude="UserId")]
    public class EditSiteUser
    {
        [Required(ErrorMessage="Du skal bekræfte adgangskode")]
        public string PasswordConfirm { get; set; }

        [Required(ErrorMessage="Du skal bekræfte e-mailadressen")]
        [Email(ErrorMessage="Ugyldig e-mailadresse")]
        public string EmailConfirm { get; set; }
        public int UserId { get; set; }

        [Required(ErrorMessage = "Du skal indtaste et brugernavn")]
        public string Username { get; set; }

        [Required(ErrorMessage = "Du skal indtaste en adgangskode")]
        public string Password { get; set; }

        [Required(ErrorMessage = "Du skal indtaste en e-mailadresse")]
        [Email(ErrorMessage = "Ugyldig e-mailadresse")]
        public string Email { get; set; }
    }

Here I have two Class-level attibutes that validate EmailConfirm and PasswordConfirm.

If a field like Username is empty, and thus yields an error, then the two EqualTo Attributes are never validated.

Does anyone have a suggestion to overcome this problem?

EDIT: If you need anymore information about this problem, please ask in comments and I will be very happy to give you any additional information you need.

Questions:
-------------------
Q: "Why is it important that the class-level checks get validated if a property-level check fails?".

A: "Because this is part of a form, where a user enters information into a form that posts back via AJAX. When the form returns it should show all current problems."

Q: "What exactly is the EqualTo attribute you have placed on the class? Is it a custom validation attribute? If so, how does it work? what does it do?"

A: EqualTo is a class-level ValidationAttribute that compares the value of two Properties of the class-instance. Look up "PropertiesMustMatchAttribute" for a similar implementation.

Property-level validation errors hinder the validation of Class-level validation

One possible issue is that jQuery Validate does [run any rules if the value of an element is empty][1]. 

You can get around this by [retriggering the validation][2] when the user loses focus:



    // select statements not firing null validation automatically
    $("select").blur(function () { $(this).valid() });

[1]: https://stackoverflow.com/a/14759805/1366033
[2]: https://stackoverflow.com/a/12195091/1366033

My view model defines property which has to be displayed as combo box. Property definition is:

    [Required]
    public int Processor { get; set; }

I'm using `DropDownListFor` to render combo box:

    <%=Html.DropDownListFor(r => r.Processor, Model.Processors, Model.Processor)%>

`Model.Processors` contains `IEnumerable<SelectListItem>` with one special item defined as:

    var noSelection = new SelectListItem
      {
        Text = String.Empty,
        Value = "0"
      };

Now I need to add validation to my combo box so that user must select different value then 'noSelection'. I hoped for some configuration of `RequiredAttribute` but it doesn't have default value setting.

Validating required selection in DropDownList

From my answer on [add class to parent div if validation error occurs using jquery validation](https://stackoverflow.com/a/39737510/1366033) because I believe it adds value to the existing answers on this question ...

# Access Validator Settings

The first order of business is to modify the `settings` object on your form's validator. You can do this in any of the following ways:

1. Before the form is loaded for all forms by calling [`jQuery.validator.setDefaults()`][setDefaults]
2. When initializing the form by passing in options on [`.validate([options])`][validate method]
3. After initialization by locating the validator object on the form with [`$("form").data("validator").settings`][validator object]

Since you're using MVC, option #2 is out of the question since [unobtrusive-validation][unobtrusive] will automatically initialize the form.  So let's use option 3 going forward - the goal here is just to be able to customize the settings on the form.

# Override Default Behavior

The default methods we'll want to modify are [`highlight`][highlight] and [`unhighlight`][unhighlight] which will *highlight* invalid fields or revert changes made by the highlight option, respectively.  Here's their default behavior [according to the source code][source]:



    highlight: function( element, errorClass, validClass ) {
		if ( element.type === "radio" ) {
			this.findByName( element.name ).addClass( errorClass ).removeClass( validClass );
		} else {
			$( element ).addClass( errorClass ).removeClass( validClass );
		}
	},
	unhighlight: function( element, errorClass, validClass ) {
		if ( element.type === "radio" ) {
			this.findByName( element.name ).removeClass( errorClass ).addClass( validClass );
		} else {
			$( element ).removeClass( errorClass ).addClass( validClass );
		}
	}


So you have a couple options here as well.

1. Completely replace those functions and write them on your own
2. Wrap those functions and call them like normal but add your own custom code before or after. 

### Option 1 - Replace Wholesale

This route is pretty easy. Just write whatever you want in there.  Maybe seed from the source code, maybe do your own thing.



    var valSettings = $("form").data("validator").settings
    valSettings.highlight = function(element, errorClass, validClass) { ... }
    valSettings.unhighlight = function(element, errorClass, validClass) { ... }


### Option 2 - Wrap Functions

This is less intrusive so probably preferable in most cases.


Since ultimately you will be replacing the value of `valSettings.highlight`, you'll need access to a clean pristine version of the original function.  You can save your own or grab one off the global defaults

    // original highlight function
    var highlightOriginal = $("form").data("validator").settings.highlight;
    var highlightDefaults = $.validator.defaults.highlight

In terms of wrapping JavaScript functions, there are a couple examples [here][wrap 1], [here][wrap 2], and [here][wrap 3]).  Here's a parsed down example from one of those, that will help bind `this` context across function calls, preserve the arity of the arguments being passed, and persist the return value:



    function wrap(functionToWrap, beforeFunction) {
        return function () {
            var args = Array.prototype.slice.call(arguments),
            beforeFunction.apply(this, args);
            return functionToWrap.apply(this, args);
        };
    };




Then you'll also have to quickly define whatever additional behavior you want to fire whenever the call is made.  In this case, let's find the closest parent `div` to the element and update it's classes like this:

    function highlightDecorator(element, errorClass, validClass) {
        $(element).closest("div").addClass(errorClass).removeClass(validClass);
    }

**Wrapping It All Up** <sup>(see what I did there)</sup>



    $(function () {
      var valSettings = $("form").data("validator").settings
      valSettings.highlight = wrap($.validator.defaults.highlight, highlightDecorator)
      valSettings.unhighlight = wrap($.validator.defaults.unhighlight, unhighlightDecorator)
    });
    
    function wrap(functionToWrap, beforeFunction) {
      return function () {
        var args = Array.prototype.slice.call(arguments);
        beforeFunction.apply(this, args);
        return functionToWrap.apply(this, args);
      };
    };
    
    function highlightDecorator(element, errorClass, validClass) {
      $(element).closest("div").addClass(errorClass).removeClass(validClass);
    }
    function unhighlightDecorator(element, errorClass, validClass) {
      $(element).closest("div").addClass(validClass).removeClass(errorClass);
    }

So when we combine all of the above functions, it should look something like this:


## Working Demo in Stack Snippets and [jsFiddle][jsFiddle]






    $(function () {
      var valSettings = $("form").data("validator").settings
    	valSettings.highlight = wrap($.validator.defaults.highlight, highlightDecorator)
      valSettings.unhighlight = wrap($.validator.defaults.unhighlight, unhighlightDecorator)
    });

    function wrap(functionToWrap, beforeFunction) {
      return function () {
        var args = Array.prototype.slice.call(arguments);
        beforeFunction.apply(this, args);
        return functionToWrap.apply(this, args);
      };
    };

    function highlightDecorator(element, errorClass, validClass) {
      $(element).closest("div").addClass(errorClass).removeClass(validClass);
    }
    function unhighlightDecorator(element, errorClass, validClass) {
      $(element).closest("div").addClass(validClass).removeClass(errorClass);
    }



    input.input-validation-error  {
      border: solid 1px red;
    }
    .input-validation-error label {
      color: red;
    }



    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.2.4/jquery.min.js"></script>
    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.16.0/jquery.validate.min.js"></script>
    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validation-unobtrusive/3.2.6/jquery.validate.unobtrusive.min.js"></script>
        
    <form action="/Person" method="post">
      
      <div class="required">
        <label for="Name">Name <em>*</em></label>           
        <input id="Name" name="Name" type="text" value="" 
               data-val="true" data-val-required="The Name field is required."/>
        <span class="field-validation-valid" 
              data-valmsg-for="Name" data-valmsg-replace="true"></span>
      </div>
      
      <input type="submit" value="Save" />
      
    </form>



 

[setDefaults]: https://jqueryvalidation.org/jQuery.validator.setDefaults/
[highlight]: https://jqueryvalidation.org/validate/#highlight
[unhighlight]: https://jqueryvalidation.org/validate/#unhighlight
[validate method]: https://jqueryvalidation.org/validate/
[unobtrusive]: https://github.com/aspnet/jquery-validation-unobtrusive
[source]: https://github.com/jquery-validation/jquery-validation/blob/1.16.0/src/core.js#L312
[validator object]: https://stackoverflow.com/a/4764443/1366033

[wrap 1]:https://stackoverflow.com/a/5259530/1366033
[wrap 2]:https://stackoverflow.com/a/326693/1366033
[wrap 3]:https://blog.sentry.io/2016/02/03/wrap-javascript-functions.html

[jsFiddle]: https://jsfiddle.net/KyleMit/p2qpn8kg/

I am using Twitter's Bootstrap as my framework for a project I am working on. I am attempting to validate a simple contact form using the jQuery Validate plugin but it's causing some headaches.

I'm looking to add an *Error* or *Valid* class to the **parent div** of each form's input. Here's my form code:

     <form id="msg-form" class="">
        <fieldset>
            <div class="input-prepend control-group pull-left">
                <span class="add-on">@</span>
                <input class="span3 required email" id="inputEmail" name="msg-email" type="text" placeholder="example@example.com">
            </div>
            <div class="input-prepend control-group pull-left">
                <span class="add-on"><i class="icon-user"></i></span>
                <input class="span3 required" id="inputName" name="msg-name" type="text" placeholder="Joe Bloggs">
            </div>
            <div class="input-prepend control-group">
                <span class="add-on" style="height: 53px;"><i class="icon-pencil"></i></span>
                <textarea class="span3 required" id="textarea" name="msg-comments" rows="2" style="height: 53px" placeholder="Just say hi, or tell us how we can help"></textarea>
            </div>
            <button type="submit" class="btn pull-right">Submit<i class="icon-chevron-right"></i></button>
        </fieldset>
    </form> 

As you can see my *div.control-group* is the div I want to add the class to. I have attempted to use the **highlight** (as suggested [here][1], but this simply didn't work) & **errorPlacement** (see below) but I'm not doing it correctly.

Ideally I want the class to be added/removed **on keyup** so it keeps the great functionality that the plugin offers. This simple code works, but it does not remove the class & only works on submission of the form:

    $("#msg-form").validate({
        errorPlacement: function(error, element) {
            $(element).parent('div').addClass('error');
        }
    });

Can anyone suggest what option I should be using to achieve this?! 

Thanks in advance -  I can provide any additional details in necessary!


  [1]: https://stackoverflow.com/questions/9929418/jquery-validate-add-class-to-error-element

jQuery Validate: add error or validate class to parent div

Assuming your class currently looks something like this:

    [ValidateThisForm]
    public class MyViewModel
    {
        public bool TestOne { get; set; }
        public bool TestTwo { get; set; }
    }

If you have complex model-level validation you want to perform, where you can't simply annotate a single property, you can hook into the validation pipeline with [`IValidatableObject`][1] like this:

    public class MyViewModel : IValidatableObject
    {
        public bool TestOne { get; set; }
        public bool TestTwo { get; set; }
        
        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        { 
          if (TestOne == false && TestTwo == false) 
          {
              yield return new ValidationResult("Form Incomplete: Please correct")
          }
        }
    }

You can continue to `yield return` as many validation messages as you'd like. And you can display them all on the client with [`@Html.ValidationSummary`][3]

If you'd like the message to appear alongside a particular control, the [`ValidationResult`][2] constructor takes an overload with the `memberNames` of the affected properties so you could change the `Validate` method like this:

    if (TestOne == false && TestTwo == false) 
    {
        yield return new ValidationResult("Form Incomplete Message", new[] {"TestOne"})
    }

Then you can provide the validation message for that particular property with the [`ValidationMessageFor`][4] HTML helper like this:

    @Html.ValidationMessageFor(Function(model) model.TestOne )

For further reading, Scott Guthrie wrote about using `IValidatableObject` as part of his [blog post introducing new features in MVC3][5] and had a follow up post with more detail on [class level validation][6] shortly thereafter.

 
[1]: https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.ivalidatableobject%28v=vs.110%29.aspx
[2]: https://msdn.microsoft.com/en-us/library/dd411880(v=vs.110).aspx
[3]: https://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.validationsummary%28v=vs.110%29.aspx
[4]: https://msdn.microsoft.com/en-us/library/system.web.mvc.html.validationextensions.validationmessagefor%28v=vs.118%29.aspx
[5]: http://weblogs.asp.net/scottgu/introducing-asp-net-mvc-3-preview-1
[6]: http://weblogs.asp.net/scottgu/class-level-model-validation-with-ef-code-first-and-asp-net-mvc-3

I have a viewmodel such that, on validation, I want to compare multiple fields. 
I have a custom attribute that takes the viewmodel and performs the required validation.
I am decorating the viewmodel class with the custom attribute [ValidateThisForm]

    [AttributeUsage(AttributeTargets.Class)]
    public class ValidateThisForm : ValidationAttribute
    {
        public override bool IsValid(object value)
        {
            ViewModel _viewModel = value as ViewModel;

            if (_viewModel.TestOne == false && _viewModel.TestTwo == false)
            {
                ErrorMessage = "Form Incomplete: Please correct";
                return false;
            }
            else
            {
                return true;
            }
        }
    }


The problem is, I want to perform several "class level" validations. As a result, in my view, I can only display these errors in one place on the form:

    <td class = "field-validation-error">@Html.ValidationMessageFor(viewmodel => viewmodel)</td>

Is there a way that I can have multiple "class level" errors being displayed in different locations on the form? 


MVC - Displaying multiple class level validation error messages

### The Problem

If you look at the html emitted by your razor view, you'll see what's at issue here.



**Without a viewmodel**, we should generate the following code (cleaned up a little):



<pre><code>&lt;input type=&quot;checkbox&quot; name=&quot;IsAdult&quot; id=&quot;<b><i>IsAdult</i></b>&quot; /&gt;
&lt;input type=&quot;text&quot; name=&quot;Comments&quot; id=&quot;Comments&quot;
       data-val-requiredif-dependprop=&quot;<b><i>IsAdult</i></b>&quot; 
       data-val-requiredif-value=&quot;Yes&quot;
       data-val-requiredif=&quot;Please leave a comment&quot; /&gt;
</code></pre>

**With a viewmodel**, we get this:



<pre><code>&lt;input type=&quot;checkbox&quot; name=&quot;PersonModel.IsAdult&quot; id=&quot;<b><i>PersonModel_IsAdult</i></b>&quot; /&gt;
&lt;input type=&quot;text&quot; name=&quot;PersonModel.Comments&quot; id=&quot;PersonModel_Comments&quot;
       data-val-requiredif-dependprop=&quot;<b><i>IsAdult</i></b>&quot; 
       data-val-requiredif-value=&quot;Yes&quot;
       data-val-requiredif=&quot;Please leave a comment&quot; /&gt;
</code></pre>

Whenever a property is nested inside another property, MVC will build a stack of prefixes to generate unique ID's and names.  You can see in the first case, `IsAdult` is enough to identify the field, however once it has been nested, the id has changed.  In unobtrusive validation (rules stored in attributes), everything we need to possibly know about how to validate an element needs to get sent along in the `data-attributes`, including how to locate other properties.

### The Solution

The data attribute on the class should never know or care about what context it is being called under, so it will continue to blindly point out the relative attribute on which it depends:



    public bool IsAdult { get; set; }
    [RequiredIf("IsAdult", "Yes", Errormessage="Please leave a comment")]
    public string Comments { get; set; }

So we'll have to establish the context either on the server or on the client.

**On the Server** - Nope!

As part of your `public class RequiredIfAttribute : ValidationAttribute, IClientValidatable`, you'll have a method that emits client side validation rules that looks something like this:

    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        ModelClientValidationRule requiredIfRule = new ModelClientValidationRule();
        requiredIfRule.ErrorMessage = ErrorMessageString;
        requiredIfRule.ValidationType = "requiredif";
        requiredIfRule.ValidationParameters.Add("dependprop", this._propertyName);
        requiredIfRule.ValidationParameters.Add("value", Json.Encode(this._value));     

        yield return requiredIfRule;
    }


The temptation here would be to navigate the `viewContext.ViewData.TemplateInfo` to return the [`GetFullHtmlFieldId`][1], but from what I can tell, this [information isn't available yet][2].

**Client** - wonky but working:

On the client, we'll wire up the adapter with a method that looks [something like this][3]:



    $.validator.unobtrusive.adapters.add('requiredif', ['dependprop', 'value'], function (options) {
        options.rules["requiredif"] = { 
            id: '#' + options.params['dependprop'],
            value: JSON.parse(options.params.value) 
        };
        options.messages['requiredif'] = options.message;
    });


Notice this still just takes the plain old property name and assumes it can be used as the ID to locate the object.

By making some reasonable assumptions, we can build the full dependency property id.  It should always be the case that the requiredif calling element is within the same scope as the property we're identify (that's how we were able to find it on the server via reflection). 

So we'll grab that context from the sender, remove that property's name, and append our own like this inside of `$.validator.unobtrusive.adapters.add`:




    var curId = options.element.id;               // get full id      i.e. ViewModel_Comments
    var context = curId.replace(/[^_]+$/, "");    // remove last prop i.e. ViewModel_
    var targetProp = options.params['dependprop'] // target name      i.e. IsAdult
    var targetId = '#' + context + targetProp;    // build target ID  i.e. #ViewModel_IsAdult

    options.rules["requiredif"] = {
        id: targetId,
        value: JSON.parse(options.params.value)
    };



That should help find the right client side property - then write whatever other conditions you need to meet.


[1]: https://msdn.microsoft.com/en-us/library/system.web.mvc.templateinfo.getfullhtmlfieldid.aspx
[2]: https://stackoverflow.com/a/24825324/1366033
[3]: https://thewayofcode.wordpress.com/tag/custom-unobtrusive-validation/

I am using the [custom RequiredIf attribute created by Simon Ince][1] in my MVC app.  

I have a viewmodel which is passed to the view like this:
    


    public class HistoryViewModel
    {
        public Contact ContactModel { get; set; }
        public Account AccountModel { get; set; }
        public Person PersonModel { get; set; }
     }

I have a bunch of models with all the props in them (i.e. contact.cs, account.cs, person.cs)



    public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public bool IsAdult { get; set; }        
        [RequiredIf("IsAdult", "Yes", Errormessage="Please leave a comment")]
        public string Comments { get; set; }
     }
     

The `RequiredIf` validation does not seem to be working when passed through the viewmodel.  It works fine if I move the properties into the viewmodel directly`.  All other `[Required]` attributes work from the model, through the viewmodel. 

*So do I need to move all the properties into the viewmodel, that need the RequiredIf on them?  Or is there another way around this?*

[1]: https://blogs.msdn.microsoft.com/simonince/2011/02/04/conditional-validation-in-asp-net-mvc-3/

Using [RequiredIf] in ASP MVC3 with ViewModels

BTW, the current answer is deprecated according to the docs on [Skipping validation on submit][1]:

>To skip validation while still using a submit-button, add the attribute `"formnovalidate"` to that input:
>
>
>    
    <input type="submit" name="go" value="Submit">
    <input type="submit" formnovalidate name="cancel" value="Cancel">

>*This used to work by adding `class="cancel"` to the input, this is now deprecated.*

Although, as of version 1.17, both methods still appear in the [source code][2]:

> **`...blob/1.17.0/src/core.js#L34`**:

>
>
    // Allow suppressing validation by adding a cancel class to the submit button
	if ( $( this ).hasClass( "cancel" ) ) {
		validator.cancelSubmit = true;
	}
>
	// Allow suppressing validation by adding the html5 formnovalidate attribute to the submit button
	if ( $( this ).attr( "formnovalidate" ) !== undefined ) {
		validator.cancelSubmit = true;
	}


Further Reading: [jQuery Validation plugin: disable validation for specified submit buttons][3]

[1]:https://jqueryvalidation.org/reference/#link-skipping-validation-on-submit
[2]: https://github.com/jquery-validation/jquery-validation/blob/1.17.0/src/core.js#L34
[3]:https://stackoverflow.com/q/203844/1366033

I have a form that I want to be able to save without validating, but validates on submit. I've got two buttons on this form to either save or submit.

The problem is: if I use a "submit" button to save (and then do a switch on which action in the controller), jquery.validate kicks in and I can't save a partially-filled out form.

If I do it as a link, I don't know how to make the form post to the new action in the controller.

Here's the HTML from the view:
    
    <a class="btn  btn-default" data-placement="right" data-title="Save your progress." href="/Summary/Save/2" rel="tooltip"><i class="glyphicon glyphicon-floppy-disk"></i> Save Summary</a> 
    <a class="btn  btn-default" confirm="Are you sure you want to revert to the previous saved copy? You will lose all changes since your last save." data-placement="right" data-title="Revert back to your last saved copy." href="/Summary/Revert/2" rel="tooltip"><i class="glyphicon glyphicon-remove"></i> Revert Changes</a> 
    <button class="btn-default  btn btn-primary" confirm="This will submit the summary to the evaluator for review. No changes will be allowed unless the evaluator returns it. Are you sure?" type="submit">Submit Summary</button>

MVC bypass client-side validation ("save progress" vs "submit")

The issue is that bootstrap-select will hide your original input and instead style it's own with divs  Here's what that looks like:

![boostrap-select DOM](http://i.imgur.com/NfGOKP0.png)

So when you submit, you should see the following error when HTML5 Validation tries to focus on your hidden control:

![not focusable](http://i.imgur.com/umznh2c.png)

According to the specs on [hidden input elements][1]

> When an input element's type attribute is in the Hidden state [...] The input element represents a value that is not intended to be examined or manipulated by the user.


As a workaround, you can toggle the visibility back on, but collapse the control.  This might cause other issues, and wouldn't actually focus the right control, but would cause the validation message to appear in the right place.

You could use the following CSS



    select.selectpicker {
      display: block !important;
      float: left;
      overflow: hidden; 
      height: 34px;
      width: 0;
      border: 0; 
      padding: 0; 
      box-shadow: none; 
      color: white; 
    }

Also, you'll want a way to transfer focus events from the original, now available, control to bootstrap-select.  This will capture both your own tab events on the forum and help redirect focus when HTML5 validation kick in.



    $("select.selectpicker").focus(function(){
      $(this).next(".bootstrap-select").find('.selectpicker').focus();
    });

**Here's a demo in stack snippets**:





    $("select.selectpicker").focus(function(){
      $(this).next(".bootstrap-select").find('.selectpicker').focus();
    });




    select.selectpicker {
      display: block !important;
      float: left;
      overflow: hidden; 
      
      height: 34px;
      width: 0;
      border: 0; 
      padding: 0; 
      
      box-shadow: none; 
      color: white; 
    }



    <link href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.2/css/bootstrap.css" rel="stylesheet"/>
    <link href="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.6.3/css/bootstrap-select.css" rel="stylesheet"/>

    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.2/js/bootstrap.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.6.3/js/bootstrap-select.js"></script>


    <form >
      <input type="text" name="name" required /><br/>
      
      <select name="select-plain" required>
        <option></option>
        <option>Mustard</option>
        <option>Ketchup</option>
        <option>Relish</option>
      </select><br/>
      
      <select name="select-boot" class="selectpicker" required>
        <option></option>
        <option>Mustard</option>
        <option>Ketchup</option>
        <option>Relish</option>
      </select><br/>
      
      <input type="submit" value="Submit"/>
    </form>



[1]: http://www.w3.org/html/wg/drafts/html/master/forms.html#hidden-state-(type=hidden)

I am using the [bootstrap-select][2] plugin, and HTML5 validation to validate the `<select>`. 


When the form is submitted without selecting the option, I am able to view the error message. However, the error message is displayed outside the form and not next to the `<select>`. 

This validation is working perfectly fine for other input fields that do not use the plugin, but has issues for any `<select>` that uses the plugin.


![Error displayed outside the form][1]

Any ideas?


  [1]: http://i.stack.imgur.com/N9UUy.png
  [2]: http://silviomoreto.github.io/bootstrap-select/

Bootstrap-select validation error placement

Instead of attaching an extra listener to the form submit, you can use the [`submitHandler`][1]:

> Callback for handling the actual submit when the form is valid.  

The default function behaves like this:



    submitHandler: function(form) {
      form.submit();
    }

> **Note**: `form` refers to a DOM element, this way the validation isn't triggered again.

Just pass in a `submitHandler` to `validate()` and add the code to disable the button like this:



    $("form").validate({
      submitHandler: function(form) {
        $(':submit', form).attr('disabled', 'disabled');
        form.submit();
      }
    });

Just be careful doing anything to the form inside of the `submitHandler` callback because it's easy to [trigger a case of infinite recursion][2]


### Here's a demo in Stack Snippets:






    $("form").validate({
      submitHandler: function(form) {
        $(':submit', form).attr('disabled', 'disabled');
        form.submit();
      }
    });

    // show message on invalid submission
    $("form").on("invalid-form.validate", function (event, validator) {
      var errors = validator.numberOfInvalids();
      if (errors) {
        alert('There is a problem with ' + errors + ' fields.');
      }
    });



    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.13.1/jquery.validate.js"></script>

    <form >
      <input type="text" name="Name" required /><br/>
      <input type="text" name="Email" required /><br/>
      <input type="submit" value="Submit"/>
    </form>




[1]: http://jqueryvalidation.org/validate/#submithandler
[2]: http://jqueryvalidation.org/documentation/#link-too-much-recursion

Using [jQuery Validate][1], is there a way to determine if a form is valid *without revalidating* the form.

Per this question on [how to add a 'submitHandler' function when using jQuery Unobtrusive Validation?][2], I'm listening to the `invalid-form.validate` event to show the user a custom error when the form has been validated and has errors.

Per this question on how to [prevent double click on submit][3], I'm disabling the submit button once the form has been submitted, but only if the form is valid, so the user can take corrective action and resubmit once the form is cleaned up.

The problem is now `invalid-form.validate` fires twice.

Since the `invalid-form.validate` event fires before my form submission handler, I'll already know the number of errors.  Does the [`.valid()`][4] method persist the number of errors somewhere that I can check against that value instead of revalidating the form.  

Here's an example in stack snippets.  Hit submit before filling in the required fields and you'll see two error messages.





    $("form").validate();

    // show message on invalid submission
    $("form").on("invalid-form.validate", function (event, validator) {
      var errors = validator.numberOfInvalids();
      if (errors) {
        alert('There is a problem with ' + errors + ' fields.');
      }
    });

    // prevent double click form submission
    $('form').submit(function () {
      if ($(this).valid()) {
        $(':submit', this).attr('disabled', 'disabled');
      }
    });




    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.13.1/jquery.validate.js"></script>

    <form >
      <input type="text" name="Name" required /><br/>
      <input type="text" name="Email" required /><br/>
      <input type="submit" value="Submit"/>
    </form>



I could save them to the the element in my `invalid-form.validate`, but this won't update when the form is valid and also couples my double click code very heavily with my custom error code.  If I take out the custom error code at some later date, I'll have to rewrite the double click prevention. 

Any ideas?


[1]: http://jqueryvalidation.org/
[2]: https://stackoverflow.com/a/4799723/1366033 
[3]: https://stackoverflow.com/a/6435544/1366033
[4]: http://jqueryvalidation.org/valid/

Check if form is valid without re-running jquery validation

You could write something like this:

```js
function parseDate(dateString) {
  var dateParts = dateString.split("/"),
      years = dateParts[0],
      months = dateParts[1],
      days = dateParts[2]
  
  // sanity check date parts
  if (days > 31) return "Invalid Date - Days"
  if (months > 12) return "Invalid Date - Months"
  
  var myDate = new Date(years, months, days)
  
  return myDate
}
```

**Demo in Stack Snippets**





    function parseDate(dateString) {
      var dateParts = dateString.split("/"),
          years = dateParts[0],
          months = dateParts[1],
          days = dateParts[2]
      
      // sanity check date parts
      if (days > 31) return "Invalid Date - Days"
      if (months > 12) return "Invalid Date - Months"
      
      var myDate = new Date(years, months, days)
      
      return myDate
    }

    console.log('2020/05/15: ', parseDate('2020/05/15'))
    console.log('2020/05/99: ', parseDate('2020/05/99'))
    console.log('2020/05/100: ', parseDate('2020/05/100'))
    console.log('2020/70/1000: ', parseDate('2020/70/1000'))

IE11's `Date.parse` function "succeeds" on a large number of invalid dates.  

Without using a third-party library, what is the proper way to validate whether a string in the format `YYYY/MM/DD` contains an actual "legal" date (e.g. "2020/02/29" succeeds, but "2019/02/29" fails, etc) in javascript?

**[Examples from IE11 console][1]:**


```js
new Date(Date.parse('2020/05/99')     // Fri Aug 07 2020
new Date(Date.parse('2020/05/100')    // Sat Aug 08 20202
new Date(Date.parse('2020/05/1000')   // Wed Jan 25 2023
new Date(Date.parse('2020/69/800000') // Fri Dec 29 4215
new Date(Date.parse('2020/69/1000')   // Sat May 27 2028
new Date(Date.parse('2020/70/1000')   // Invalid Date
```

  [1]: https://i.stack.imgur.com/j0jzK.png
