Sunday, December 29, 2013

Step By Step How to add Model Data Validation (Code First) to an ASP.NET MVC 4 application

         By Carmel Schvartzman

In this tutorial we'll learn how  to add Model Data Validation to an ASP.NET MVC4 application, while using the Code First approach of the Entity Framework

Concerning the Model in a MVC application, there are two kinds of errors that can happen: data type errors and bussiness logic errors. The later are usually handled in special classes which extend the DAL of the application. Remember that when you use the Entity Framework as the DAL (Data Access Layer) of your MVC, every time you update the conceptual data model to reflect changes made to the data store, the Model classes are regenerates by a tool, meaning that everything that's in it is erased and rewriten. Therefore the Bussiness Rules are coded in partial classes which extends the Model classes.

For that reason, decorating entities's fields with Data Annotaions will not work while using the Database First approach of the Entity Framework. Every time you refresh the conceptual Model, your annotations will be overriden. In this tutorial we'll use Data Annotations with the  the Code First approach.

The MVC Data Model created automatically by the Entity Framework captures the data type errors caused by incompatibility between data types, and throws exceptions notificating the user about the problems.

This kind of errors can be easily handled using Data Annotations, by decorating the entity's fields with attributes. That way, custom validation rules will be enforced not only while persisting data to the store, but whenever MODEL-BINDING OPERATIONS are performed by MVC.
The  following validator attributes are supported:
   Range – checks if the value of a property is between a specified range.
   ReqularExpression – checks whether the value matches a specified regular expression.
   Required – sets a property as required.
   StringLength –  checks whether a maximum length for a string property is legal.
There is also the option of inheriting from the base class "Validation" in order to enforce custom validation.
First think we must do is adding the System.ComponentModel.DataAnnotations namespace to the entity class we want to validate:

Let's say we have an entity named "User" with the following properties:

We want to ensure the FirstName and LastName have been typed in, therefore we'll use the "Required" attribute:

Next, we can force the user to enter an address fullfilling certain requirements, and for that we can use the StringLenght attribute:

The Annotation will end as follows, and also we can set what the message error will be:

For the Phone property, we'll use the DataType attribute to specify which type must be entered (currently with .Net Framework 4.5 there are 17 valid predefined types allowed, such as "EmailAddress" or "PostalCode", but also you can use CUSTOM TYPES defining your own class):

We'll choose the "PhoneNumber" type, and some Error Message to be presented to the user:

Finally, we'll want to validate the user's Credit Card number, and in this case we could use a RegularExpression to enforce some specific type of Credit card, as follows:

Or also use the DataType attibute as follows:

These Data Annotations will enforce the user to enter valid input, but also will protect the system from dangerous input like sql injections.

That's all!! 
Happy programming.....

כתב: כרמל שוורצמן