ASP.NET MVC Model Validation

Model Validation: 

Validations are required for ensuring that the received data is valid and correct so that we can do the further processing with the data.

Validate in action method: We can validate model in action method. We can check the values of properties of the model object and register any errors we find with the ModelState property.

We can check to see whether the model binder was able to assign a value to a property by using the ModelState.IsValidField method. We do this make sure that the model binder was able to parse the value the user submitted; so that can perform additional checks.

Example:

if (string.IsNullOrEmpty(model.UserName))

{

      ModelState.AddModelError("UserName", "Please enter your user name");

}

if (!model.TermsAccepted)

{

      ModelState.AddModelError("TermsAccepted", "You must accept the terms");

}

if (ModelState.IsValid)

{

      //send model for further processing

}

ValidationSummary: The validation summary displays the error messages that we registered with the ModelState in our action method. There are a number of overloaded versions of the ValidationSummary method.

Method	Description
Html.ValidationSummary()	Generates a summary for all validation errors.
Html.ValidationSummary(bool)	If the bool parameter is true, then only model-level errors are displayed. If the parameter is false, then all errors are shown.
Html.ValidationSummary(string)	Displays a message before a summary of all the validation errors.
Html.ValidationSummary(bool,string)	Displays a message before the validation errors. If the bool parameter is true, only model-level errors will be shown.

ValidationMessage: The Html.ValidationMessageFor helper displays validation errors for a single model property.

@Html.ValidationMessageFor(m => m.UserName)

Validation in the Model Binder: The default model binder performs validation as part of the binding process. The model binder performs some basic validation for each of the properties in the model object. If value has not been supplied or value that cannot be parsed into the model property type. DefaultModelBinder, provides us with some useful methods that we can override to add validation to a binder. Find detail in below table.

Method Name	Description	Default Implementation
OnModelUpdated	Called when the binder has tried to assign values to all of the properties in the model object. Model level validation.	Applies the validation rules defined by the model metadata and registers any errors with ModelState.
SetProperty	Called when the binder wants to apply a value to a specific property. Property level validation	Required or not valid message will show.

Data Annotations: The MVC Framework supports the use of metadata to express model validation rules. We can easily add validation to our application by including Data Annotations namespace and use attributes to our model classes. Data Annotations allow us to describe the rules we want applied to our model properties, and ASP.NET MVC will take care of enforcing them and displaying appropriate messages to our users. There is number of attribute classes which inherits validation attribute class, use to manage different types of validation.

Some of important build in data annotation attributes are:

• Required – Indicates that the property is a required field
• DisplayName – Defines the text we want used on form fields and validation messages
• StringLength – Defines a maximum length for a string field
• Range – Gives a maximum and minimum value for a numeric field
• RegularExpression – Validate input value as per defined regular expression
• Compare – Two property must have same value.

Custom validation class: We can also create custom validation attribute by deriving from the ValidationAttribute class and implementing our own validation logic. We can override the IsValid method of the base class, this method get called by binder while passing value provided by user as the parameter.

Example:

public class MustBeTrueAttribute : ValidationAttribute

    {

        public override bool IsValid(object value)

        {

            return value is bool && (bool)value;

        }

    }

[Display(Name = "I accept the terms & conditions")]

[MustBeTrue(ErrorMessage = "You must accept the terms")]

public bool TermsAccepted { get; set; }

Model Validation Attribute: We can also create a custom attribute at model level instead of property level. Model validator attribute will use only if property-level attributes does not register a validation error. We must apply a model validation attribute to the model class itself.

Example:

public class RegisterValidatorAttribute : ValidationAttribute

    {

        public RegisterValidatorAttribute()

        {

            ErrorMessage = "Please enter valid email";

        }

        public override bool IsValid(object value)

        {

            RegisterModel model = value as  RegisterModel;

            if (model.Email.Contains("test") || model.Email.Contains("test.com"))

            {

                return false;

            }

            return true;

        }

    }

[RegisterValidator]

public class RegisterModel

Client-Side Validation: In web application user expect immediately validation, without having to submit data to the server. This is client site validation and usually we implement JavaScript for this. This allow user to correct data before sending to the server for further processing.

The MVC Framework supports unobtrusive client-side validation. The term unobtrusive means that validation rules are expressed using attributes added to the HTML elements that we generate. These are interpreted by a JavaScript library that is included as part of the MVC Framework, which uses the attribute values to configure the jQuery Validation library, which does the actual validation work. There are few advantages using this approach.

• We do not have to include client-side validation logic into our views
• If JavaScript disabled in browser then server side validation will fire in same manner.
• Mitigate the effect of browser inconsistencies and behaviors.

Enable/Disable Client validation: Developer can enable and disable client side validation by setting in web.config. By default it’s enabled.

<appSettings>

    <add key="ClientValidationEnabled" value="true"/>

    <add key="UnobtrusiveJavaScriptEnabled" value="true"/>

 </appSettings>

Both of these settings must be true for client-side validation to work. We can also set value programmatically like in global.asax page application start method.

protected void Application_Start()

{

HtmlHelper.ClientValidationEnabled = true;

HtmlHelper.UnobtrusiveJavaScriptEnabled = true;

}

We can enable or disable client-side validation for individual views as well by setting above value in view page.

In addition to the configuration settings, we must references three specific JavaScript libraries.

<script src="@Url.Content("~/Scripts/jquery-1.5.1.min.js")" type="text/javascript"></script>

<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript"></script>

<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript"></script>

After all above setting client side validation will start to work based on applied metadata attributes in model properties such as Required, Range, Regular Expression and String Length.

Client side validation works faster and also perform validation on key stroke like key press or focus change.

In MVC Framework validation rules are expressed using HTML attributes. MVC client-side validation is that the same attributes we use to specify validation rules are applied at the client and at the server.  

Example:

Without validation attribute:

public string UserName { get; set; }

Output:

<input id="UserName" name="UserName" value="" type="text">

With validation attribute:

[Required]

public string UserName { get; set;

Output:

<input id="UserName" name="UserName" value="" type="text" data-val-required="The User name field is required." data-val="true">

Note: The MVC client-validation features are built on top of the jQuery Validation library; developer can use the Validation library directly and ignore the MVC features if required. The MVC client-validation features hide the JavaScript, and they have the advantage of taking effect for both client- and server-side validation.

Example:

<script type="text/javascript">

$(document).ready(function ()

{

    $('form').validate({

    errorLabelContainer: '#validtionSummary',

    wrapper: 'li',

    rules: {

        UserName: {

            required: true,

        }

    },

    messages: {

        UserName: "Please enter your user name"

    }

    });

});

</script>

The jQuery Validation library supports some more complex validation rules like email, url, date, number, digits and credit card or we can create new rules.

Creating attributes for client-side validation: To enable client-side validation, we must implement the IClientValidatable in model attribute class. We can create custom validation attributes that work in the same way as the built-in ones and that trigger client- and server-side validation.

The interface defines one method, GetClientValidationRules, which returns an enumeration of

ModelClientValidationRule objects. Each ModelClientValidationRule object describes the client-side validation rule that we want to apply, the error message to display when the rule is broken, and any parameters that the rule needs to operate.

Example:

Example to create a new rule called checkboxmusttrue to ensure that a checkbox is checked.

Developer has to add custom jQuery validation rule to unobtrusive adaptor.

<script type="text/javascript">

    jQuery.validator.unobtrusive.adapters.add("checkboxmusttrue", function (options) {

        if (options.element.tagName.toUpperCase() == "INPUT" &&

options.element.type.toUpperCase() == "CHECKBOX") {

            options.rules["required"] = true;

            if (options.message) {

                options.messages["required"] = options.message;

            }

        }

    });

</script>

public class MustBeTrueAttribute : ValidationAttribute, IClientValidatable

    {

        public override bool IsValid(object value)

        {

            return value is bool && (bool)value;

        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)

        {

            return new ModelClientValidationRule[] {    new ModelClientValidationRule {

            ValidationType = "checkboxmusttrue",

                    ErrorMessage = this.ErrorMessage

            }};

        }

    }