Step By Step How to add Bussiness Logic Validation to an ASP.NET MVC 4 Application

         By Carmel Schvartzman

In this tutorial we'll learn how  to add Bussiness Logic Validation to an ASP.NET MVC4 application. 

Concerning the Model in a MVC application, there are two kinds of errors that can happen: data type errors or bussiness logic errors. While the data type errors are usually handled using Data Annotations, 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 usually coded in partial classes which extend the Model classes.

The Bussiness Logic comprehends both Application Logic (the logic of the interaction between the user and the specific application we developed - web win etc) and Data Store Logic (the logic concerning exclusively the data, no matter which kind of application you have).

The Application Logic will usually  be on the Controllers, because it concerns to the specific application, an MVC app in our case.

The Bussiness Data Logic MUST BE located in the Model, in a separate BLL (Bussiness Logic Layer) folder, and usually is coded in partial classes which extend the DAL (Data Access Layer) created for example by the Entity Framework.

In this tutorial we'll create a BLL (Bussiness Logic Layer) coding partial classes which extend the DAL (Data Access Layer). Let's say we have an MVC 4 app connected to an SQL SERVER database with the following tables on it:

We'll state that the user can save temporarily a comment with a Title but no text, or with a Text but no Title. But it is not allowed to save a comment without text and without title. This is a Bussiness Data Logic rule, which we'll code in an extension of the corresponding Comments Entity.

Focus the Model folder and create a new class on it. Inside, code the extension of the Comment class which we want to enable to apply our Bussiness rule:

Add a MetaData class named CommentMetaData, as we did in a previous tutorial , in order to enable Data Type Validation:

Next, do the Comment class to implement the IValidatableObject:

This way will allow us to code a Validate() method to perform the necessary bussiness logic on our entity, returning an IEnumerable collection holding all input errors.


Add the Validate method with its returned ValidationResult collection:

Finally, code the required if clause stating that we wont persist an user comment only in case of the lack of both Title and Text: 

Now let's make use of the IValidatableObject: provided that you already have a form where the user will type her/his comment. If you don't, referer to this tutorial . Go to the Home Controller and find the method which handles POST requests:


There, add an if clause using our Validate() method, which IEnumerable results count will be 0 only in case of valid input:



Open the Comment's form and save two comments, the first having only a Title but no text, the second having Text but no Title:

Now check the database to see the persisted records:

Then try to persist a Comment with no Title nor Text:

The comment has not been saved, because our extended Comment entity didn't allow that.
To see it from inside, set a breakpoint in the Validate() method, and try to save an empty Comment again. You'll see that the runtime enters the if clause , avoiding saving the record:

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

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

Step By Step How to add Model Data Validation (Database 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 Database 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 Annotations 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 Database 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.

Let's say we have an entity named "Comment" mapped to the database table Comment with the following properties:

Notice that the "Title" column holds strings up to 100 characters. We'll try to enter comments with a title longer than that, to check the Data Validation.
In order to check it, create a new test class in the Model folder:

This static class contain a method which just creates a new Comment, add it to the context, and tries to persist it to the database. The Data Model Validation of the Entity Framework will automatically refuse to do that and will throw an DbEntityValidationException:

The exception, however, doesn't reveal us which field caused it:

We' want to catch this exception in a friendly user way and inform what is causing the problem.
To do that, we'll create a MetaData class with the necessary Data Annotations, and extend the partial class Comment created by the Entity Framework to link it to the metadata file.

Therefore we'll extend the Comments class taking care to copy exactly the name of the class:

Copy this to a new file named CommentMetaData.cs, containing the following two classes:

First think we must do is adding the System.ComponentModel.DataAnnotations namespace to the entity class we want to validate:

Add an attribute setting the MetaData Class for the Comment class:

Now copy the properties you want to add validation to, from the original class Comment:

And paste them, adding the necessary validation attributes, specifying the maximal lenght of the Title:

Next, we'll add a View to create Comments, to see how it works:

Add the corresponding Action to the Home Controller:

And the ActionLink to the Menu in the _Layout.cshtml file:

Finally, add the Action to cope with Comments creation, on the Home Controller:

Rebuild the MVC project (F6) and browse to the Comments Page:

In it, type some valid data to check if it's saved correctly:

Check the data in the database. Yes, it was persisted:

Now type some invalid input, and try to save it:

The Message error that you wrote on the MetaData class is presented to the User to inform her/him that the length of the Title was illegal, and the Comment is not saved:

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

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

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.....

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