You can disable this implicit validation by setting the [`AddImplicitRequiredAttributeForValueTypes`][1] option on the [`DataAnnotationsModelValidatorProvider`][2] by adding the following to your `Application_Start`:
 


 DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

**Further Reading**:

* [Unrequired property keeps getting data-val-required attribute][3]
* [ASP.NET MVC optional field being treated as required][4]
* [Why MVC Model Binder set required for int, long values?][5]






[1]:https://msdn.microsoft.com/en-us/library/system.web.mvc.DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes
[2]:https://msdn.microsoft.com/en-us/library/system.web.mvc.DataAnnotationsModelValidatorProvider
[3]: https://stackoverflow.com/q/4700172/1366033
[4]: https://stackoverflow.com/q/13293207/1366033
[5]: https://stackoverflow.com/q/17143001/1366033

This is happening when I try to create the entity using a Create style action in Asp.Net MVC 2.


The POCO has the following properties:

    public int Id {get;set;}

    [Required]
    public string Message {get; set}

On the creation of the entity, the Id is set automatically, so there is no need for it on the Create action.

The ModelState says that "The Id field is required", but I haven't set that to be so. 
Is there something automatic going on here?

**EDIT - Reason Revealed**

The reason for the issue is answered by Brad Wilson via Paul Speranza in one of the comments below where he says (cheers Paul): 

> You're providing a value for
> ID, you just didn't know you were.
> It's in the route data of the default
> route ("{controller}/{action}/{id}"),
> and its default value is the empty
> string, which isn't valid for an int.
> Use the [Bind] attribute on your
> action parameter to exclude ID. My
> default route was: new { controller =
> "Customer", action = "Edit", id = " "
> } // Parameter defaults

**EDIT - Update Model technique**

I actually changed the way I did this again by using TryUpdateModel and the exclude parameter array asscoiated with that. 

        [HttpPost]
        public ActionResult Add(Venue collection)
        {
            Venue venue = new Venue();
            if (TryUpdateModel(venue, null, null, new[] { "Id" }))
            {
                _service.Add(venue);
                return RedirectToAction("Index", "Manage");
            }
            return View(collection);
        }


"The Id field is required" validation message on Create; Id not set to [Required]

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

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

## The Problem 

Validation Attributes have two environments they can validate against:

1. Server
2. Client

### Server Validation - Multiple Attributes Easy
If you have any attribute with:



<pre><code>[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
public class RequiredIfAttribute : ValidationAttribute</code></pre>

And have put it on your class property like this:

<pre><code>public class Client
{
 public short ResidesWithCd { get; set; };

 [RequiredIf(nameof(ResidesWithCd), new[] { 99 }, "Resides with other is required.")]
 public string ResidesWithOther { get; set; }
}</code></pre>


Then anytime the **Server** goes to [validate an object][1] (ex. `ModelState.IsValid`), it will check every [`ValidationAttribute`][2] on each property and call [`.IsValid()`][3] to determine validity. This will work fine, even if <code><a href="https://msdn.microsoft.com/en-us/library/System.AttributeUsageAttribute" title="System.AttributeUsageAttribute">AttributeUsage</a>.<a href="https://msdn.microsoft.com/en-us/library/System.AttributeUsageAttribute.AllowMultiple" title="System.AttributeUsageAttribute.AllowMultiple">AllowMultiple</a></code> is set to true.

### Client Validation - HTML Attribute Bottleneck

If you enable client side by implementing [`IClientValidatable`][4] like this:



<pre><code>public IEnumerable&lt;ModelClientValidationRule&gt; GetClientValidationRules(ModelMetadata metadata, ControllerContext context) 
{
 var modelClientValidationRule = new ModelClientValidationRule
 {
 ValidationType = "requiredif",
 ErrorMessage = ErrorMessageString
 };
 modelClientValidationRule.ValidationParameters.Add("target", prop.PropName);
 modelClientValidationRule.ValidationParameters.Add("values", prop.CompValues);

 return new List&lt;ModelClientValidationRule&gt; { modelClientValidationRule };
}
</code></pre>

Then ASP.NET will emit the following HTML when generated: 

(As long as <code><a href="https://msdn.microsoft.com/en-us/library/System.Web.Mvc.ViewContext.ClientValidationEnabled" title="System.Web.Mvc.ViewContext.ClientValidationEnabled">ClientValidationEnabled</a></code> &
<code><a href="https://msdn.microsoft.com/en-us/library/System.Web.Mvc.ViewContext.UnobtrusiveJavaScriptEnabled" title="System.Web.Mvc.ViewContext.UnobtrusiveJavaScriptEnabled">UnobtrusiveJavaScriptEnabled</a></code> are enabled)



<pre><code>&lt;input class="form-control" type="text" value=""
 id="Client_CommunicationModificationDescription" 
 name="Client.CommunicationModificationDescription" 
 data-val="true"
 data-val-requiredif="Communication Modification Description is required."
 data-val-requiredif-target="CommunicationModificationCd"
 data-val-requiredif-values="99" &gt;
</code></pre>

Data Attributes are the only vehicle we have for dumping rules into the client side validation engine which will search for any attributes on the page via a built in or custom **adapter**. And once part of the set of client side rules, it'll be able to determine the validity of each parsed rule with a built in or custom **method**.

So we can call jQuery Validate Unobtrusive to look for and parse these attributes by **adding a custom adapter** which will add a validation rule to the engine:

<pre><code>// hook up to client side validation
$.validator.unobtrusive.adapters.add('requiredif', ['target', 'values'], function (options) {
 options.rules["requiredif"] = {
 id: '#' + options.params.target,
 values: JSON.parse(options.params.values)
 };
 options.messages['requiredif'] = options.message;
});
</code></pre>


We can then tell that rule how function and determine validity by adding a custom method like this which will add a custom way to evaluate `requiredif` rules (as opposed to date rules or regex rules) which will rely on the parameters we loaded earlier through the adapter:

<pre><code>// test validity
$.validator.addMethod('requiredif', function (value, element, params) {
 var targetHasCondValue = targetElHasValue(params.id, params.value);
 var requiredAndNoValue = targetHasCondValue && !value; // true -> :(
 var passesValidation = !requiredAndNoValue; // true -> :)
 return passesValidation;
}, '');
</code></pre>

Which all operates like this:

[![IClientValidatable][5]][5]


# Solution

So, what have we learned? Well, if we want the same rule to appear multiple times on the same element, the adapter would have to see the exact set of rules multiple times per element, with no way to differentiate between each instance within multiple sets. Further, ASP.NET won't render the same attribute name multiple times since it's not valid html.

So, we either need to:

1. Collapse all the client side rules into a single *mega* attribute with all the info
2. Rename attributes with each instance number and then find a way to parse them in sets.

I'll explore **Option One** (emitting a single client side attribute), which you could do a couple ways:

1. Create a single Attribute that takes in multiple elements to validate on the server client
2. Keep multiple distinct server side attributes and then merge all attributes via reflection before emitting to the client

In either case you will have to re-write the client side logic (adapter/method) to take an array of values, instead of a single value at a time.

To we'll build/transmit a JSON serialized object that looks like this:



 var props = [
 {
 PropName: "RoleCd",
 CompValues: ["2","3","4","5"]
 },
 {
 PropName: "IsPatient",
 CompValues: ["true"]
 }
 ]


### `Scripts/ValidateRequiredIfAny.js`

Here's how we'll handle that in client side adapter / method:



 // hook up to client side validation
 $.validator.unobtrusive.adapters.add("requiredifany", ["props"], function (options) {
 options.rules["requiredifany"] = { props: options.params.props };
 options.messages["requiredifany"] = options.message;
 });
 
 // test validity
 $.validator.addMethod("requiredifany", function (value, element, params) {
 var reqIfProps = JSON.parse(params.props);
 var anytargetHasValue = false;
 
 $.each(reqIfProps, function (index, item) {
 var targetSel = "#" + buildTargetId(element, item.PropName);
 var $targetEl = $(targetSel);
 var targetHasValue = elHasValue($targetEl, item.CompValues);
 
 if (targetHasValue) {
 anytargetHasValue = true;
 return ;
 }
 });
 
 var valueRequired = anytargetHasValue;
 var requiredAndNoValue = valueRequired && !value; // true -> :(
 var passesValidation = !requiredAndNoValue; // true -> :)
 return passesValidation;
 
 }, "");

 // UTILITY METHODS

 function buildTargetId(currentElement, targetPropName) {
 // https://stackoverflow.com/a/39725539/1366033
 // we are only provided the name of the target property
 // we need to build it's ID in the DOM based on a couple assumptions
 // derive the stacking context and depth based on the current element's ID/name
 // append the target property's name to that context
 
 // currentElement.name i.e. Details[0].DosesRequested
 var curId = currentElement.id; // get full id i.e. Details_0__DosesRequested
 var context = curId.replace(/[^_]+$/, ""); // remove last prop i.e. Details_0__
 var targetId = context + targetPropName; // build target ID i.e. Details_0__OrderIncrement
 
 // fail noisily
 if ($("#" + targetId).length === 0)
 console.error(
 "Could not find id '" + targetId +
 "' when looking for '" + targetPropName +
 "' on originating element '" + curId + "'");
 
 return targetId;
 }

 function elHasValue($el, values) {
 var isCheckBox = $el.is(":checkbox,:radio");
 var isChecked = $el.is(":checked");
 var inputValue = $el.val();
 var valueInArray = $.inArray(String(inputValue), values) > -1;
 
 var hasValue = (!isCheckBox || isChecked) && valueInArray;
 
 return hasValue;
 };

### `Models/RequiredIfAttribute.cs`

On the server side, we'll validate attributes like normal, but when we got to build the client side attributes, we'll look for all attributes and build one mega attribute



 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Reflection;
 using System.Web.Helpers;
 using System.Web.Mvc;

 [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
 public class RequiredIfAttribute : ValidationAttribute, IClientValidatable
 {

 public PropertyNameValues TargetProp { get; set; }

 public RequiredIfAttribute(string compPropName, string[] compPropValues, string msg) : base(msg)
 {
 this.TargetProp = new PropertyNameValues()
 {
 PropName = compPropName,
 CompValues = compPropValues
 };
 }
 protected override ValidationResult IsValid(object value, ValidationContext validationContext)
 {
 PropertyInfo compareProp = validationContext.ObjectType.GetProperty(TargetProp.PropName);
 var compPropVal = compareProp.GetValue(validationContext.ObjectInstance, null);
 string compPropValAsString = compPropVal?.ToString().ToLower() ?? "";
 var matches = TargetProp.CompValues.Where(v => v == compPropValAsString);
 bool needsValue = matches.Any();

 if (needsValue)
 {
 if (value == null || value.ToString() == "" || value.ToString() == "0")
 {
 return new ValidationResult(FormatErrorMessage(null));
 }
 }

 return ValidationResult.Success;
 }


 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
 // at this point, who cares that we're on this particular instance - find all instances
 PropertyInfo curProp = metadata.ContainerType.GetProperty(metadata.PropertyName);
 RequiredIfAttribute[] allReqIfAttr = curProp.GetCustomAttributes<RequiredIfAttribute>().ToArray();

 // emit validation attributes from all simultaneously, otherwise each will overwrite the last
 PropertyNameValues[] allReqIfInfo = allReqIfAttr.Select(x => x.TargetProp).ToArray();
 string allReqJson = Json.Encode(allReqIfInfo);

 var modelClientValidationRule = new ModelClientValidationRule
 {
 ValidationType = "requiredifany",
 ErrorMessage = ErrorMessageString
 };

 // add name for jQuery parameters for the adapter, must be LOWERCASE!
 modelClientValidationRule.ValidationParameters.Add("props", allReqJson);

 return new List<ModelClientValidationRule> { modelClientValidationRule };
 }
 }

 public class PropertyNameValues
 {
 public string PropName { get; set; }
 public string[] CompValues { get; set; }
 }


Then we can bind that to our model by applying multiple attributes simultaneously:



 [RequiredIf(nameof(RelationshipCd), new[] { 1,2,3,4,5 }, "Mailing Address is required.")]
 [RequiredIf(nameof(IsPatient), new[] { "true" },"Mailing Address is required.")]
 public string MailingAddressLine1 { get; set; }

**Further Reading**

* [ASP.NET MVC custom multiple fields validation][6] by [Stephen Muecke][7]
* [Unobtrusive Client Validation in ASP.NET MVC 3][8] by [Brad Wilson][9]



[1]: https://stackoverflow.com/a/28433753/1366033
[2]: https://msdn.microsoft.com/en-us/library/System.ComponentModel.DataAnnotations.ValidationAttribute "System.ComponentModel.DataAnnotations.ValidationAttribute"
[3]: https://msdn.microsoft.com/en-us/library/System.ComponentModel.DataAnnotations.ValidationAttribute.IsValid "System.ComponentModel.DataAnnotations.ValidationAttribute.IsValid"
[4]: https://msdn.microsoft.com/en-us/library/System.Web.Mvc.IClientValidatable "System.Web.Mvc.IClientValidatable"
[5]: https://i.stack.imgur.com/ctjB0.png
[6]: https://stackoverflow.com/a/42036235/1366033
[7]: https://stackoverflow.com/users/3559349/stephen-muecke
[8]: http://bradwilson.typepad.com/blog/2010/10/mvc3-unobtrusive-validation.html
[9]: https://stackoverflow.com/users/1554/brad-wilson

[99a]: https://msdn.microsoft.com/en-us/library/System.AttributeUsageAttribute "System.AttributeUsageAttribute"
[99b]: https://msdn.microsoft.com/en-us/library/System.AttributeUsageAttribute.AllowMultiple "System.AttributeUsageAttribute.AllowMultiple"
[99c]: https://msdn.microsoft.com/en-us/library/System.Web.Mvc.ViewContext.ClientValidationEnabled "System.Web.Mvc.ViewContext.ClientValidationEnabled"
[99d]: https://msdn.microsoft.com/en-us/library/System.Web.Mvc.ViewContext.UnobtrusiveJavaScriptEnabled "System.Web.Mvc.ViewContext.UnobtrusiveJavaScriptEnabled"

How can I use Same Custom Validation Attribute Multiple Times on Same Field or simply enable AllowMultiple=true, for both server side and client side validation??

I have a following Custom Validation Attribute:

    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, 
            AllowMultiple = true, Inherited = true)]
    public class RequiredIfAttribute : ValidationAttribute,IClientValidatable
    {
        public RequiredIfAttribute(string dependentProperties, 
         string dependentValues = "",
         string requiredValue = "val")
         {
         }
    }

Where in dependentProperties I can specify multiple dependant properties seperated by comma, in dependentValues I can specify for which values of dependant properties validation should process and finally in requiredValue I can specify expected value for the field to be validated.

In my model there are two properties LandMark, PinCode and I want to use validation as follows:

    public string LandMark { get; set; }
    [RequiredIf("LandMark","XYZ","500500")]
    [RequiredIf("LandMark", "ABC", "500505")]
    public string PinCode { get; set; }

The values here are just for example, as per it seems I can add the attribute multiple times and don't get any compile error, I have implemented TypeID in attribute and it works well from serverside if I remove client validation from it. But when I am implementing IClientValidatable on the attribute, it gives me an error:

"Validation type names in unobtrusive client validation rules must be unique."

Any help how can I solve it??


Custom Validation Attribute Multiple Times on same field

The accepted answer is great if the type is an integer, but a lot of ids wind up being typed as a string to prevent losing leading zeros. You can format a string by breaking it up into pieces with `Substring` and make it reusable by sticking it in a DisplayTemplate.

Inside `/Shared/DisplayTemplates/`, add a template named `Phone.vbhtml`:



 @ModelType String
 @If Not IsNothing(Model) AndAlso Model.Length = 10 Then
 @@String.Format("({0}) {1}-{2}",
 Model.Substring(0, 3),
 Model.Substring(3, 3),
 Model.Substring(6, 4))
 Else
 @Model
 End If

You can invoke this in a couple ways:

1. Just annotate the property on your model with a data type of the same name:

 
 
 <DataType("Phone")> _
 Public Property Phone As String

 And then call using a simple `DisplayFor`:

 
 
 @Html.DisplayFor(Function(model) model.Phone)

2. Alternatively, you can specify the DisplayTemplate you'd like to use by name:

 
 
 @Html.DisplayFor(Function(model) model.VimsOrg.Phone, "Phone")

Is there a way I can use the `DisplayFormat` attribute on a view model property to apply a `DataFormatString` format for a social security number or a phone number?  I know I could do this with javascript, but would prefer to have the model handle it, if possible.

    [DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "???????")]
    public string Ssn { get; set; }



DisplayFormat.DataFormatString for a phone number or social security number

You can also set the property type to [`Nullable<T>`][1], and then just manually enforce any required validation you might need to do before working with the database.



 public int? Id {get;set;}

**Further Reading**:

* [Unrequired property keeps getting data-val-required attribute][2]
* [ASP.NET MVC optional field being treated as required][3]
* ["The Id field is required" validation message on Create][4]



[1]: https://msdn.microsoft.com/en-us/library/b3h38hb0.aspx
[2]: https://stackoverflow.com/q/4700172/1366033
[3]: https://stackoverflow.com/q/13293207/1366033
[4]: https://stackoverflow.com/q/2142990/1366033

 I have a Model Like this

    public int Id {get;set;}

    [Required]
    public string FirstName{get; set}
    [Required]
    public string LastName{get; set}

The Id is auto generate in DB. when I want call Create action The ModelState says that "The Id field is required"!!!! I Found [this][1] for my problem but it not clean solution.
Is there an other way to solve this?

Is there a way that I change Mvc ModelBinder behavior for value types?


  [1]: https://stackoverflow.com/questions/2142990/asp-mvc-the-id-field-is-required-validation-message-on-create-id-not-set-to

Why MVC Model Binder set required for int, long values?

Here's another approach from [How to create custom validation attribute for MVC][1], which is adapted from this article on [ASP.NET MVC Custom Validation][2]:

    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
    public class AlphaNumericAttribute: RegularExpressionAttribute
    {
        private const string pattern = "^[-A-Za-z0-9]+$";
    
        public AlphaNumericAttribute() : base(pattern)
        {
            // necessary to enable client side validation
            DataAnnotationsModelValidatorProvider.RegisterAdapter(
                typeof(AlphaNumericAttribute), 
                typeof(RegularExpressionAttributeAdapter));
        }
    }

By using [`RegisterAdapter`][3], you can leverage the integrations that already exist for regular expressions for your own inherited type.

[1]: https://stackoverflow.com/a/5954452/1366033
[2]: http://haacked.com/archive/2009/11/19/aspnetmvc2-custom-validation.aspx/
[3]: https://msdn.microsoft.com/en-us/library/system.web.mvc.dataannotationsmodelvalidatorprovider.registeradapter(v=vs.118).aspx

I have created the following custom RegularExpressionAttribute

 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
 public class AlphaNumericAttribute: RegularExpressionAttribute, IClientValidatable
 {
 public AlphaNumericAttribute()
 : base("^[-A-Za-z0-9]+$")
 {
 }

 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
 yield return new ModelClientValidationRule { ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()), ValidationType = "alphanumeric" };
 }
 }

The field in the ViewModel is decorated with my AlphaNumeric attribute:

 [AlphaNumeric(ErrorMessageResourceType = typeof(Resources), ErrorMessageResourceName = Resources.DriverLicenseNumber_RegexError_)]
 public string DriverLicenseNumber { get; set; }

The field is built in the view:

 @using (Html.BeginForm("Index", "Application", FormMethod.Post, new { id = "applicationDataForm", autocomplete = "off" }))
 {
 @Html.LabelFor(m => m.DriverLicenseNumber)
 @Html.ValidationMessageFor(m => m.DriverLicenseNumber)
 @Html.TextBoxFor(m => m.DriverLicenseNumber)
 }

This should yield the proper *"data-"* validation attributes on my html input tag. However, the rendered tag looks like this:

 <input data-val="true" data-val-alphanumeric="Please enter a valid driver's license number." id="DriverLicenseNumber" name="DriverLicenseNumber" type="text" value="" maxlength="20" class="valid">

Conspicuously absent are the *data-val-regex* and *data-val-regex-pattern* attributes that are supposed be rendered. 

I have built other validators with the exact same structure, and they work correctly, like this SSN validation which handles masked spaces for a masked input using jquery masking:

 public class SsnAttribute : RegularExpressionAttribute, IClientValidatable
 {
 public SsnAttribute()
 : base("^([0-9]{3}–[0-9]{2}–[0-9]{4})|([ ]{3}–[ ]{2}–[ ]{4})|([0-9]{9,9})$")
 {
 }

 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
 yield return new ModelClientValidationRule { ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()), ValidationType = "ssn" };
 }
 }

With the accompanying application on the ViewModel:

 [Ssn(ErrorMessageResourceType = typeof(Resources), ErrorMessageResourceName = Resources.SocialSecurity_RegexError_)]
 public new string SocialSecurityNumber { get; set; }

The field is built in the view:
 
 @using (Html.BeginForm("Index", "Application", FormMethod.Post, new { id = "applicationDataForm", autocomplete = "off" }))
 {
 @Html.LabelFor(m => m.SocialSecurityNumber)
 @Html.ValidationMessageFor(m => m.SocialSecurityNumber)
 @Html.TextBoxFor(m => m.SocialSecurityNumber)
 }

This validation attribute correctly renders the data-val-regex and data-val-regex-pattern attributes:

 <input class="SSNMask valid" data-val="true" data-val-regex="Please enter a valid social security number." data-val-regex-pattern="^([0-9]{3}–[0-9]{2}–[0-9]{4})|([ ]{3}–[ ]{2}–[ ]{4})|([0-9]{9,9})$" id="SocialSecurityNumber" name="SocialSecurityNumber" type="text" value="" maxlength="22">

 
I cannot figure out what I am missing with the AlphaNumeric attribute that it does not render the appropriate html attributes.

Custom RegularExpressionAttribute missing data-val-regex-pattern for client-side validation

If you look at the Description for the [`ShortName` property][1] on the [`Display` Attribute][2] you'll see that it has a pretty limited scope out of the box:

![Short Name Description][3]

Of course, that doesn't limit you from leveraging that value on your Model Metadata, but there aren't any native helpers that do so.

[Starting with MVC 2][4], [`ModelMetadata`][5] provides two methods to access the underlying data: `FromStringExpression` and `FromLambdaExpression`, so you don't really need to start from scratch in writing your own helper or extension method.

If you *hate* writing HTML helper methods, you can do this all inline:



 @ModelMetadata.FromLambdaExpression<RegisterModel, string>( 
 model => model.TransferDate, ViewData).ShortDisplayName} ) 

But it's also perfectly valid to add an extension method for consistency of access, deduplication of code, and improved error handling


 
 public static class MvcHtmlHelpers
 {
 public static MvcHtmlString ShortNameFor<TModel, TValue>(this HtmlHelper<TModel> self, 
 Expression<Func<TModel, TValue>> expression)
 {
 var metadata = ModelMetadata.FromLambdaExpression(expression, self.ViewData);
 var name = metadata.ShortDisplayName ?? metadata.DisplayName ?? metadata.PropertyName;
 
 return MvcHtmlString.Create(string.Format(@"{0}", name));
 }
 }

And then use like any other helper method:



 @Html.ShortNameFor(model => model.TransferDate)




**Further Reading**:

* [How do I display the DisplayAttribute.Description attribute value?][9]
* MVC has long subsisted on custom extension methods, like [needing DisplayNameFor before it was added in MVC 4][6] 
* See this question for a quick [breakdown of the differences between `[Display(name="")]` vs. `[DisplayName("")]` attributes][7] 
* See this answer for [working with ASP.NET MVC 6 / Core 1][8]

[1]: https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.displayattribute.shortname.aspx
[2]:https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.displayattribute.aspx "System.ComponentModel.DataAnnotations.DisplayAttribute"
[3]: http://i.stack.imgur.com/PwPkI.png
[4]: http://bradwilson.typepad.com/blog/2009/10/aspnet-mvc-2-templates-part-2-modelmetadata.html
[5]: https://msdn.microsoft.com/en-us/library/system.web.mvc.modelmetadata.aspx "System.Web.Mvc.ModelMetadata"
[6]: https://stackoverflow.com/q/3885796/1366033
[7]: https://stackoverflow.com/q/5243665/1366033
[8]: https://stackoverflow.com/a/35294035/1366033
[9]: https://stackoverflow.com/a/6578828/1366033

Name attribute works proper, but ShortName doesn't work. 

    [Display(Name = "Date of the transfer the task", ShortName = "Trans date")]
    public DateTime TransferDate { get; set; }

Even when I delete Name attribute, ShortName is ignored ("TransferDate" displays in the column header).

In the view I do this:

    @Html.DisplayNameFor(model => model.TransferDate)



ShortName in the Display attribute (DataAnnotations)

Adapted Jon Davis's answer on [Unit Testing ASP.NET DataAnnotations validation][1]

If you have a class like this:

```cs
public class Person
{
 [MinLength(3, ErrorMessage = "FIRSTNAME_LENGTH_MIN")]
 public string FirstName { get; set; }

 [MinLength(3, ErrorMessage = "MOBILENUMBER_LENGTH_MIN")]
 public string MobileNumber { get; set; }
}
```

You can test the validation results like this:


```cs
[TestMethod]
public void ModelValidationFailsWithInvalidLength()
{
 // arrange
 var myPerson = new Person()
 {
 FirstName = "Hi",
 MobileNumber = "12"
 };

 // act
 var validationResults = ValidateModel(myPerson);

 // assert
 Assert.IsTrue(validationResults.Any(
 v => v.MemberNames.Contains(nameof(Person.FirstName)) &&
 v.ErrorMessage.Contains("FIRSTNAME_LENGTH_MIN")));
}

private IList<ValidationResult> ValidateModel(object model)
{
 var validationResults = new List<ValidationResult>();
 var ctx = new ValidationContext(model, null, null);
 Validator.TryValidateObject(model, ctx, validationResults, true);
 return validationResults;
}
```


[1]: https://stackoverflow.com/a/4331964/1366033

I was trying to do unit testing for validations on c# models using Validator but it is not working with NewtonSoft attributes. 

Here's my unit test:


```cs
var searchController = new SearchController();
var requestModel = new RequestModel
{
 Id = "23456",
   MobileNumber = "9876543210"
};

var results = new List<ValidationResult>();
var context = new ValidationContext(requestModel, null, null);
var isvalid = Validator.TryValidateObject(requestModel, context, results,true);
Assert.IsFalse(isvalid);
```


And here's my model:

```cs
public class XYZ
{
 [JsonProperty("mobileNumber")]
 [MinLength(3, ErrorMessage = "MOBILENUMBER_LENGTH_MIN")]
 public string MobileNumber { get; set; }

 [JsonProperty("refNumber")]
 [MinLength(3, ErrorMessage = "REFNUMBER_LENGTH_MIN")]
 public string RefNumber { get; set; }

 [JsonProperty("subscriberFirstName")]
 [MinLength(3, ErrorMessage = "FIRSTNAME_LENGTH_MIN")]
 public string FirstName { get; set; }
}
```

Can someone help me with this?

Unit testing for Validation Attributes in c#

### *TLDR*: `[Phone]` provides validation logic while `[DataType]` does not

The inheritance chain looks like this:

`Attribute` 
&nbsp;&nbsp;↳ `ValidationAttribute` 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;↳ `DataTypeAttribute` 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;↳ `PhoneAttribute`

So both are instances of `ValidationAttribute`, however both don't provide Validation out of the box. The DataType base class just provides the structure for assigning an `enum DataType` and leaves overriding the validation up to the caller

### `DataType` - According to the Docs:

> When you apply the `DataTypeAttribute` attribute to a data field you must do the following:
>
> * Issue validation errors as appropriate.

### `DataType` - According to the Source Code:



 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Parameter, AllowMultiple = false)]
 public class DataTypeAttribute : ValidationAttribute
 {
 /// <summary> Override of <see cref="ValidationAttribute.IsValid(object)" /> </summary>
 /// <remarks>This override always returns <c>true</c>. Subclasses should override this to provide the correct result.</remarks>
 /// <param name="value">The value to validate</param>
 /// <returns>Unconditionally returns <c>true</c></returns>
 /// <exception cref="InvalidOperationException"> is thrown if the current attribute is ill-formed.</exception>
 public override bool IsValid(object value)
 {
 EnsureValidDataType();
 
 return true;
 }
 }

**Aside**: Since you are required to override `IsValid`, I'm not sure why .NET didn't mark the class and property as [`abstract`][10] to guarantee an implementation programmatically.


### `PhoneAttribute` - Validation Logic

So if you do want to provide validation, and you're using .NET 4.5+ or .NET Core, you can use the `[Phone]` attribute, but the mechanism for validation has changed over time as well and also you might have a different set of rules on what constitutes valid input for your business process.

.NET Framework initially used the following regular expression:



 const string pattern = @"^(\+\s?)?((?<!\+.*)$\+?\d+([\s\-\.]?\d+)?$|\d+)([\s\-\.]?($\d+([\s\-\.]?\d+)?$|\d+))*(\s?(x|ext\.?)\s?\d+)?$";

But this was deprecated in .NET Framework 4.7.2 per [this change description][11], likely due to injection/security concerns layed out in the [Regular Expression Best Practices][12] from unconstrained input. 

If you want to continue using regex validation, you'd have to set the following in the `configuration` > `appsettings` section of your `.config` file:



 <add key="dataAnnotations:dataTypeAttribute:disableRegEx" value="false"/>
 
The Test project includes a sample of what inputs should pass/fail according to [PhoneAttributeTests.cs][16] and here's a [Regexr page][17] if you want to test out matching input against the (deprecated) regular expression validation engine.



-----


Here's some links for source code and documentation for different flavors of .NET:



<pre><code> | .NET Core | .NET Core 2.1 | .NET 4.7.2 | .NET |
------------------|-------------------|----------------|-----------------|----------------|
DataTypeAttribute | <a href="https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs">github.com/dotnet</a> | <a href="https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs">source.dot.net</a> | <a href="https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/DataTypeAttribute.cs">referencesource</a> | <a href="https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute">docs.microsoft</a> |
PhoneAttribute | <a href="https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/PhoneAttribute.cs">github.com/dotnet</a> | <a href="https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/PhoneAttribute.cs">source.dot.net</a> | <a href="https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/PhoneAttribute.cs">referencesource</a> | <a href="https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute">docs.microsoft</a> |
</code></pre>

**Note**: The current docs for `[Phone]` mistakenly remarks that the validation uses Regular Expressions, which has not been true since 4.7.2+ or anywhere in .NET core, so I've [submitted this PR to update][15]

[1]: https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs
[2]: https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/PhoneAttribute.cs
[3]: https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/DataTypeAttribute.cs
[4]: https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/PhoneAttribute.cs
[5]: https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs
[6]: https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/PhoneAttribute.cs
[7]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute "System.ComponentModel.DataAnnotations.DataTypeAttribute"
[8]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute "System.ComponentModel.DataAnnotations.PhoneAttribute"

[10]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract
[11]: https://github.com/Microsoft/dotnet/blob/master/Documentation/compatibility/aspnet-472-compat-doc.md
[12]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/best-practices
[15]: https://github.com/dotnet/dotnet-api-docs/pull/686
[16]: https://source.dot.net/#System.ComponentModel.Annotations.Tests/System/ComponentModel/DataAnnotations/PhoneAttributeTests.cs
[17]: https://regexr.com/429je

What's the difference between using [`DataType` Attribute][1] and passing in a value of [`DataType.Phone`][3] and the [`Phone` Attribute][2] which inherits from `DataType` and automatically sets `DataType.Phone`?


Is there any difference between these two classes?



<pre><code>class Person {
 [DataType(DataType.PhoneNumber)]
 public string PhoneNumber {get;set;}
}
</code></pre>



<pre><code>class Person {
 [Phone]
 public string PhoneNumber {get;set;}
}
</code></pre>

[1]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute "System.ComponentModel.DataAnnotations.DataTypeAttribute"
[2]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute "System.ComponentModel.DataAnnotations.PhoneAttribute"
[3]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataType "System.ComponentModel.DataAnnotations.DataType"