ashish

Model is an important component of any MVC application , the M in MVC , which represents the data and the business rules with which our application works.The Model component represents the business entities for our application’s domain by different Model classes.

So if our application manages Employees in an organization then the Model class to represent the employees may be represented by an Employee class.Our Model classes can consist of just the  properties representing the data or they can define the business rules as well.

The data which the user enters on the screen is assigned to the model properties in the controller.As this data is part of our business domain so it is important to validate it.User should be allowed to enter only the valid data.Allowing invalid data would sacrifice the integrity of our application and could make it unstable.So model validation should be a part of any MVC application.

Model validation means to validate the data our application works with.If the user enters any data incorrectly or doesn’t provides any required information then the user should be notified.

There are few different approaches by which we can perform the Model validation to verify if the data entered by the user is valid.Some of the ways we can validate the data are:-

• Explicitly validating the data in the action methods
• Using Data-annotation attributes to perform validation
• Using client side validation
• Defining custom validation attributes

Explicitly Performing validation in the action methods We can explicitly perform model validation in action methods. If any particular property is not valid as per the business rules defined for our application then we can add the error for that property to the ModelState property. Our controller inherits ModelState property from the base controller class.

We will be using the following employee class for our validation

public class Employee
{
public int EmpId { get; set; }
public string Name { get; set; }
public string Department { get; set; }
public string Address { get; set; }
public DateTime JoiningDate { get; set; }
public string Email { get; set; }
}

Though the above class defines just the properties we can also define methods for the business rules in our Model class.To perform validation we need to verify the property value. For example to make the Name property as mandatory we can add the following error message

if(string.IsNullOrEmpty(emp.Name))
 {
   ModelState.AddModelError("Name", "Please enter name");
 }

To add the error to the ModelState we use it’s AddModelError method.If there are any errors added to the ModelState then IsValid property value will be false ,which we can check to see the presence of any validation errors.

if (!ModelState.IsValid)
 return View();
      else
  return View("Completed");

If there are no validation errors then we return the “completed” view else we return the same view.

Property errors   We can specify the property errors by providing a key when adding the error message to the ModelState.

ModelState.AddModelError("Name", "Please enter name");

We can display the property errors in a view by passing false value to the @Html.ValidationSummary helper method.

@Html.ValidationSummary(false)

Model errors   We can specify the Model errors by leaving the key as empty when adding the error message to the ModelState.

ModelState.AddModelError("", "Model error");

We can display the Model errors in the view by passing true value to the @Html.ValidationSummary helper method.

@Html.ValidationSummary(true)

We create a strongly typed view for the Employee class and then just add the HtmlHelper method for validation as highlighted below.

@using (Html.BeginForm("Details", "Home"))
{
<table >
<tr>
<td colspan="2">@Html.ValidationSummary()</td>
<td> </td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.EmpId)</td>
<td>@Html.TextBoxFor(x=>x.EmpId) </td>
</tr>

<tr>
<td>@Html.LabelFor(x=>x.Name)</td>
<td>@Html.TextBoxFor(x=>x.Name) </td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Department)</td>
<td> @Html.TextBoxFor(x=>x.Department)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Address)</td>
<td>@Html.TextBoxFor(x=>x.Address)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.JoiningDate)</td>
<td>@Html.TextBoxFor(x=>x.JoiningDate)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Email)</td>
<td>@Html.TextBoxFor(x=>x.Email)</td>
</tr>
<tr>
<td><input type="submit" name="submit" /></td>
</tr>
</table>
}

If we don’t enter the value in the Name field and submit the form then we get the error “Please enter name”.

Performing model validation using data annotations  We can attach the metadata to the model class using the  attributes in the System.ComponentModel.DataAnnotations  namespace.We can apply the attributes defined in this namespace to apply the validation rules for the class properties.For example we can make a property as mandatory using the Required attribute.

The important validation attributes defined in the System.ComponentModel.DataAnnotations namespace are:-

• Required    Ensures that the property value is mandatory
• StringLength    Ensures that the length of property lies between minimum and maximum values
• ReqularExpression    Ensures the value of a property is equal to the pattern specified by the regular expression
• Range      Ensures that the value of a property lies between the specified range
• Compare  Ensures value of a property is equal to the specified property value
• Url    Ensures that the value of a property is a valid URL.
• Email  Ensures that the value of a property is a valid email address.

In the following Employee class we have applied the Required,Range, Comapre,Url and EmailAddress attributes to the properties.

public class Employee
{
[Required]
[Range(2,4)]
public int EmpId { get; set; }
[Required]
public string Name { get; set; }
[Required]
public string Department { get; set; }
public string Address { get; set; }
public DateTime JoiningDate { get; set; }
public string Status { get; set; }
[EmailAddress]
public string Email { get; set; }
[EmailAddress]
[Compare("EmailAddress")]
public string ConfirmEmail { get; set; }
[Url]
public string Url { get; set; }
 }

We create the strongly typed view for the Employee class as below.We have added the validation HtmlHelper methods ValidationSummary() and ValidationMessageFor() for displaying the validation errors.

@using (Html.BeginForm("Details", "Home"))
{
<table >
<tr>
<td colspan="2">@Html.ValidationSummary()</td>
<td> </td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.EmpId)</td>
<td>@Html.TextBoxFor(x=>x.EmpId) @Html.ValidationMessageFor(x => x.EmpId)</td>
</tr>

<tr>
<td>@Html.LabelFor(x=>x.Name)</td>
<td>@Html.TextBoxFor(x=>x.Name) @Html.ValidationMessageFor(x => x.Name)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Department)</td>
<td> @Html.TextBoxFor(x=>x.Department)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Address)</td>
<td>@Html.TextBoxFor(x=>x.Address)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.JoiningDate)</td>
<td>@Html.TextBoxFor(x=>x.JoiningDate) @Html.ValidationMessageFor(x => x.JoiningDate)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Email)</td>
<td>@Html.TextBoxFor(x=>x.Email) @Html.ValidationMessageFor(x => x.Email)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.ConfirmEmail)</td>
<td>@Html.TextBoxFor(x=>x.ConfirmEmail) @Html.ValidationMessageFor(x => x.ConfirmEmail)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Status)</td>
<td>@Html.TextBoxFor(x=>x.Status)</td>
</tr>
<tr>
<td>@Html.LabelFor(x=>x.Url)</td>
<td>@Html.TextBoxFor(x=>x.Url) @Html.ValidationMessageFor(x => x.Url)</td>
</tr>

<tr>
<td><input type="submit" name="submit" /></td>
</tr>
</table>
}

In the page rendered by the Employee view we enter the values for the EmpId and Email fields and leave the other fields blank.

If we submit the form we will get the below validation errors.Please note that we have just applied the validation attributes to the model properties and the default validation messages are provided by these attributes.We have not written any validation code.Automatic model validation is an advantage of using the data annotations to validate the model.

Client Side validation The user entered data is validated on the client instead of the server.User is informed of the validation errors immediately instead of waiting for the response from the server.

To validate the model on the client we can follow the below steps

1) Enable the ClientValidationEnabled and UnobtrusiveJavaScriptEnabled keys in the appSettings section of the web.config.

<appSettings>
<add key="webpages:Version" value="3.0.0.0" />
<add key="webpages:Enabled" value="false" />
<add key="ClientValidationEnabled" value="true" />
<add key="UnobtrusiveJavaScriptEnabled" value="true" />
</appSettings>

2) Client validation uses the jquery validation library which we need to install.We can install the required javascript nuget packages using the following commands in the package manager console

Install-Package jQuery –version 1.10.2
Install-Package jQuery.Validation –version 1.11.1
Install-Package Microsoft.jQuery.Unobtrusive.Validation –version 3.0.0

3) Once we have the required javascript libraries we need to reference the them in the views.We can reference the following libraries in the layout view so that client validation can be used in all the views.

<script src="~/Scripts/jquery-1.10.2.js"></script>
<script src="~/Scripts/jquery.validate.js"></script>
<script src="~/Scripts/jquery.validate.unobtrusive.js"></script>

4) We just need to apply the data annotation attributes to the model class and the validation will automatically happen on the client instead of the server now.

If we take the example of the employee class then once the reference to the javascript libraries is added and the form is submitted then the data is not posted back to the server ,instead user is notified of the errors immediately.The advantage of doing validation on the client is that it saves a trip to the server for performing validation.

Validation happens on the client 

Defining custom validation attributes We can create custom validation attribute by deriving from the ValidationAttribute class.ValidationAttribute is an abstract class which defines IsValid method.We can define our custom validation logic by implementing the IsValid method.

We can create a custom validation attribute for the Employee class as

public class ValidateEmplooyeeAttribute : ValidationAttribute
{
 protected override ValidationResult IsValid(object value, ValidationContext validationContext)
 {
 if (value != null)
 {
    Employee employee = value as Employee;
    if (string.IsNullOrEmpty(employee.Name) && (DateTime.Compare(employee.JoiningDate, DateTime.Now)<0))
 {
   return new ValidationResult("Please Enter a valid Name."); 
 }
  
 }
   return ValidationResult.Success;
 }
}

The above class verifies if the name is empty.If the name is empty it returns a ValidationResult object and passes  the error message as a constructor parameter.

The advantage of defining a custom validation attribute is that we can implement validation functionality not provided by the built in validation attributes.

So as we have seen there are different ways we can perform Model validation in our MVC application.We can select the most appropriate approach depending on the scenario.

Follow on:

Filters  

Filter is implemented as an attribute which defines the common functionality or the cross cutting concern.The logic contained in a filter executes when the action method with which the filter is attached executes.Common examples of such cross cutting concerns are the logging and the caching functionality .Logging is used across the different layers in an application so it makes sense to encapsulate such functionality.

Instead of duplicating such functionality across different action methods and controllers ,we can encapsulate the common functionality in a filter.So we define a filter once and then apply it to the different controllers and action methods.

We can apply a filter to an action method or to a controller,applying a filter to a controller has the same effect as applying the filter to each of the action methods in a controller.

So the following two code snippets are effectively the same :-

1)Attaching filter to a controller

In the following example we are attaching the HandleError filter to the Home Controller.

[HandleError]
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}

public ActionResult About()
{
return View();
}
}

2)Attaching filter to action methods in a controller

In the following example we are attaching the HandleError filter to each of the action methods in the Home Controller..

public class HomeController : Controller
{
[HandleError]
public ActionResult Index()
{
return View();
}
[HandleError]
public ActionResult About()
{
return View();
}
}

Different types of filters

Filters are classified in the following types according to the types of functionality which they provide and there sequence in the request processing pipeline. Also different filter types implements different interfaces.Filters and their execution sequence is as follows

• Authentication filters    Verifies if the request can execute the action method
• Authorization filters      Verifies if the request is Authorized to execute the action method
• Action filters       Provides functionality which is executed before and after the action method executes
• Result filters       Provides functionality which is executed before and after the action result executes
• Exception filters   Provides functionality which executes if an unhandled error occurs

The above filters are called in a sequence.So ,if we both the Authentication and the Authorization filters are attached to an action method ,the Authentication filter will be called before the Authorization filter 

Lets see how we can use the above filters

Authentication filter  is the first filter to execute and is used to authenticate the request.Authentication filter was introduced in MVC 5.

Authentication filter implements the filter IAuthenticationFilter interface which is defined as

 public interface IAuthenticationFilter
 {
void OnAuthentication(AuthenticationContext filterContext);
void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext);
 }

OnAuthetication method is the first of all the filter methods which gets called.We can allow or deny access to the user making the request in this method.So this is the method in which we can implement our authentication policy.It is passed a parameter of the type AuthenticationContext. AuthenticationContext has a property Result of type ActionResult.

If we want to deny the access to action method for the current request then we can assign a HttpUnauthorizedResult object to the Result property as:-

public class AuthenticationAttribute : ActionFilterAttribute, IAuthenticationFilter
 {
public void OnAuthentication(AuthenticationContext filterContext)
{
filterContext.Result = new HttpUnauthorizedResult();
}
public void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
 {
// filterContext.Result = new ViewResult();
 }
}

If we apply the AuthenticationAttribute to any action method the following login screen is displayed.As we have set the result property to HttpUnauthorizedResult type so the user is redirected to the login screen.

Authorization filter implements the IAuthorizationFilter interface which is defined as

public interface IAuthorizationFilter {
void OnAuthorization(AuthorizationContext filterContext);
}

Instead of creating a custom Authorization filter attribute ,there is a built in AuthorizeAttribute which we can use to define the authorization policy. This attribute has two important properties

• Users A comma separated list of users who are allowed to access the action method.
• Roles A comma separated list of roles which are allowed to access the action method.

The following Authorize attribute limits the access to the action method only to the user “user1”.

[Authorize(Users="user1")]
public ActionResult Index()
{
return View();
}

Action filter  We use action filters to define the functionality which we want to execute before an action method executes or after an action method executes.

Normally we define custom functionality using the Action filters.Though there are few built in Action filters also.OutputCache is an example of a built in action filter

Action filters implements the IActionFilter interface.This interface is defined as

public interface IActionFilter {
void OnActionExecuting(ActionExecutingContext filterContext);
void OnActionExecuted(ActionExecutedContext filterContext);
}

• OnActionExecuting  defines the functionality which we want to execute before the action method executes
• OnActionExecuted defines the functionality which we want to execute after the action method executes

So we can define an action filter by defining a class implemeting IActionFilter interface as:-

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class ActionTestAttribute : FilterAttribute, IActionFilter
{
public void OnActionExecuted(ActionExecutedContext filterContext)
{
filterContext.HttpContext.Response.Write("Action method executed.");
}
public void OnActionExecuting(ActionExecutingContext filterContext)
{
filterContext.HttpContext.Response.Write("Action method going to execute </br>");
}
}

So we get the following response in browser if we apply the above filter attribute to any action method.

As we have implemented the OnActionExecuting  and OnActionExecuted methods so our filter logic executes before the action method executes and after the action method executes.

Result filter  Defines functionality which executes after the action result is returned by the action method.Result filters implement the interface IResultFilter which is defined as

public interface IResultFilter {
void OnResultExecuting(ResultExecutingContext filterContext);
void OnResultExecuted(ResultExecutedContext filterContext);
}

• OnResultExecuting     executes after the action result is returned by the action method but before the action result executes
• OnResultExecuted       executes after the action result completes execution.

Exception filter  We use exception filters to handle exceptions which are not handled in our action method.Exception filters implements the interface IExceptionFilter  which is defined as:-

public interface IExceptionFilter {
void OnException(ExceptionContext filterContext);
}

The OnException method is called when an unhandled exception occurs.

Instead of creating a class implementing the IExceptionFilter interface we can use the built in HandleError attribute. HandleError attribute defines the following two important properties

• ExceptionType   The type of exception the HandleError attribute will handle
• View     The view that is rendered if an unhandled error occurs.

To handle the ArgumentNullException we can apply the HandleError attribute as

[HandleError(ExceptionType=typeof(ArgumentNullException),View="CustomError")]
public ActionResult Details(int id)
{
return View();
}

If no value is passed for the action method’s id parameter then the view  specified in the View property will be displayed to the user.

Overriding the Controller base class methods

As we have seen above we can create custom filters  by creating an attribute and then attaching the attribute to the controller or the action method.Instead of explicitly defining the attributes implementing these interfaces we can directly implement the methods defined by these interfaces in the controller class.The controller class implements all the the different filter interfaces.

As the controller class implements these filter interface so it defines the methods declared by these interfaces.These methods are defined as virtual which we can override in our controller class :-

protected virtual void OnActionExecuted(ActionExecutedContext filterContext);
protected virtual void OnActionExecuting(ActionExecutingContext filterContext);
protected virtual void OnAuthentication(AuthenticationContext filterContext);
protected virtual void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext);
protected virtual void OnAuthorization(AuthorizationContext filterContext);
protected virtual void OnException(ExceptionContext filterContext);
protected virtual void OnResultExecuted(ResultExecutedContext filterContext);
protected virtual void OnResultExecuting(ResultExecutingContext filterContext);

So instead of applying the action filter attributes to our action methods or the controller we can override the above methods in our controller class as:-

public class HomeController : Controller
{
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
// executes before the action method execution 
}

protected override void OnActionExecuted(ActionExecutedContext filterContext)
{
// executes after the action method executes
}

}

So we can use the different types of filters for implementing cross cutting concerns and avoid the code duplication.

Follow on:

Before looking into how to use the HTML helper methods in MVC Views let’s first understand what are the problems that HTML helpers solves.

HTML helpers have a very specific use which is to generate the HTML for the containing view. In any web page we need a form element which may contain some child HTML elements like the input fields to enable the user to provide input values and  interact with our application.

Though we can write the html elements ourselves,after all html elements consists of simple opening and closing tags, but the HTML helpers generates html tags for us and we don’t have to write all the boilerplate code. If we take the example of the form tag ,it is written as

<form action="”url”" method="”get”"> </form>

The action attribute points to the url to which our web page will be submitted while the method attribute can be Get or Post.

If we write the above HTML then we need to verify if our url is correctly refering to the action method in the controller which complies with the routes defined by our application

We can generate the similar html using the BeginForm() html helper.But if we use the BeginForm() html helper method then the generated form tag will use the correct routing configuration for the action method.Also if the routing configuration changes in our application BeginForm()  will take care of it.

So following are the benefits of  HTML helpers over writing the html elements ourselves.

• We don’t have to worry about forgetting the closing tag or any any other markup as the html is generated by another well tested component  the “HTMLHelper method” which ensures that only valid html is generated.
• Writing html elements by hand in a large enterprise application can get tedious. We don’t  need to write boilerplate code again and again.
• HTML helpers provides few features by default like encoding attribute values to prevent cross site scripting attacks ,generated url’s points to the correct server resources and binding the html elements to the model object so the model changes are reflected in the html elements.

HTML helpers are implemented as methods which generate chunk of HTML.Helper methods can be accessed in a view using the HTML property.Every view has an implicit base class.In the case of razor views it is WebViewPage and for the WebForms views it is ViewPage which defines the HTML property for which all the extension methods are defined ,so the helper methods are accessible via the HTML property in all the views which we create.

There are two versions of the HTML helper methods the normal html helper methods and strongly typed.The difference is that the normal HTML helpers are unaware of the model for the view while the strongly typed version knows about the model.

As the strongly typed version is aware of the model so any changes in the model such as changing the name of the property or removing a property are recognized.So an advantage of using the strongly typed helper methods is that errors such as typing wrong property name are caught at compile time instead of runtime.

Another advantage of the strongly typed methods is that we get the visual studio intellisense support which is not available for the normal helper methods.

We will see common HTML helpers along with the strongly typed versions and the html elements that they generate.

@Html.BeginForm   The BeginForm helper method generates the form element.It posts to a controller action method which we can specify as the method parameters.The following BeginForm() method will post to the EmployeeDetails  method of the Home Controller.

@using (Html.BeginForm("EmployeeDetails", "Home"))
{

}

If we don’t specify a value for the action method and controller parameters then by default the BeginForm() method posts to the same action method and controller which returned the view.

Html helpers for form elements have a normal strongly typed version.Unlike normal html helper methods in which we pass a string literal ,we pass a model object as lambda expression parameter to the strongly typed methods.

@Html.TextBox   We can use the TextBox helper method to generate input field for the user.It renders the input html tag with the type attribute set to “text”.

It has different overloads which we can use to specify different properties like html attributes and the format.We can use the following overload to specify the name ,value and the html attributes for the textbox.

@Html.TextBox(String nameOfTextBox, Object value, Object htmlAttributes)

If we call the method with  the below argument values

@Html.TextBox("name", "john", new { id = "nameId" })

we get the following html rendered by the helper .Since we have explicitly set the value of the id attribute in the helper above it is rendered in the input tag.If we don’t explicitly set the value of id then the id value will be same as the name.

<input id="nameId" name="name" type="text" value="john" />

Strongly typed version of the TextBox helper is TextBoxFor().So to render a textbox for name property we use the TextBoxFor() helper as

@Html.TextBoxFor(model => model.name)

As with other strongly typed helper methods it expects a lambda expression.

 @Html.DropdownList and @Html.Listbox   These  are used to generate the list with multiple values from which user can select single or multiple values,dropdownlist allows single selection while listbox helper selects multiple selection.Both of these helpers are rendered as a select element.The difference between the two is that dropdownlist helper method renders a dropdown list in which only a single item can be selected while listbox helper renders a list which allows to select multiple items at a time.

We can use the DropDownList method to render a list containing three items in which the item with value 3 is selected as

@Html.DropDownList("courses", new SelectList(
new List<Object>{
new { Text = "Computers", Value = 1 },
new { Text = "Electronics", Value = 2 },
new { Text = "Mechanical", Value = 3}
},
"Value",
"Text",
3))

We get the following dropdown on executing the view containing the above code.Mechanical list item is selected as we have given the select index as 3 above.

If we want to create  a listbox instead of dropdownlist we can use the listbox helper method as

@Html.ListBox("courses", new SelectList(
new List<Object>{
new { Text = "Computers", Value = 1 },
new { Text = "Electronics", Value = 2 },
new { Text = "Mechanical", Value = 3}
},
"Value",
"Text",
3))

The following listbox is rendered by the above listbox helper method.

@Html.Password  This renders an input password field ,in which user typed value is masked so that it is not visible on screen. To generate a password field having id password we can use the following helper method
@Html.Password(“password”)

in the generated input field entered values are not visible on screen

The above Password helper renders the following input element
<input id=”password” name=”password” type=”password” />

@Html.Hidden This renders a hidden field with id and value being set with the method arguments.If we have a id field in our model then we can use the following to set the field with its value.
@Html.Hidden(“id”)

The following input element will be generated by using the above helper method.The value is set as 1 below as it is the value of the id field in the model.

<input id="id" name="id" type="hidden" value="1" />

We can use the strongly typed method also to set the hidden field with the id value as

@Html.HiddenFor(model=>model.id)

If we want to set the hidden field with some other value then we can pass the value explicitly as

@Html.Hidden("id","11")

@Html.RadioButton   HTML Radiobutton displays a list of choices from which user can select a single value.Radiobuttons are usually placed in a group with each each radio button having the same name.We can use the RadioButton helper to generate the html radio buttons.

Below we are creating radio buttons for three products from which user can select a single product.We have passing the same name to the three helper methods so that the rendered radio buttons will belong to the same group.To the second  method we are passing the value true for the third argument as we want the tv radio button selected by default.

<span>computer</span> @Html.RadioButton("product", "computer")
<span>tv</span> @Html.RadioButton("product", "tv", true)
<span>mp3</span> @Html.RadioButton("product", "mp3")

The above methods displays a group of radio buttons.

Following html is rendered by the above methods

<input id="product" name="product" type="radio" value="computer" />
<input checked="checked" id="product" name="product" type="radio" value="tv" />
<input id="color" name="product" type="radio" value="mp3" />

We can bind the htmlhelper method to a model property using the strongly typed version.So if we have a model property called product

@Html.RadioButtonFor(model => model.product, "1")
@Html.RadioButtonFor(model => model.product, "2")
@Html.RadioButtonFor(model => model.product, "3")

 @Html.CheckBox  This renders a checkbox which user can select or deselect.It acts as a true/false field. To render a checkbox with name print we can use it as

@Html.CheckBox("print")

If we want to make the rendered checkbox selected by default then we can pass the value true to the second argument.

@Html.CheckBox("print",true)

The strongly typed version binds to a boolean model property.If we have a boolean model property print then we can call the method as

@Html.CheckBoxFor(model=>model.print)

@Html.ActionLink   We can create an HTML link using this helper method.This is one of the most useful methods since it takes care of the routing information .Routes are not only responsible for matching the incoming urls but also helps generate outgoing urls,which are urls which are generated as a part of our view rendering.

For example if we want to render a hyperlink which posts to the Details action of the Home controller then we will use the following

@Html.ActionLink("Employee Details","Details","Home")

The first parameter above is the link text, and the second parameter is the name of the controller action.

It renders the following HTML:

<a href="/Home/About">About this Website</a>

The above link is generated by checking the routing information defined by our application.So we should use the ActionLink() helper for generating the outgoing urls instead of hardcoding the urls in our views.

@Html.ValidationSummary   This is used to show the errors to the user.It renders a list which contains the errors which are contained in the ModelState dictionary.

In the action method we can add the errors in the ModelState dictionary.We can add the errors as model errors or as property errors.

ModelState.AddModelError("", "This is a Model error");  //model error
ModelState.AddModelError("propertyerror", "This is a Property error"); //property error

To display the errors we can use the helper method as

@Html.ValidationSummary(false)//displays model errors
@Html.ValidationSummary(true)//displays property errors

So as we have seen above Html helper methods in MVC renders html markup.They also help avoid code redundancy and provide few features like encoding out of the box.

If we need some functionality which is not covered by the the inbuilt helpers we can create our own helper methods.

Follow on: