Category Archives: Asp.Net MVC

Asp.Net MVC

@Html.Action vs @Html.RenderAction in Asp.Net MVC

@Html.Action

  • @Html.Action returns string.
  • Syntax : @Html.Action(“Action”,”Controller”).
  • Pass parameter with Action method Syntax : @Html.Action(“Action”,”Controller”, new {ParameterName=ParameterValue}).
  • It is slower as compared to @Html.RenderAction.
  • It’s result can be manipulated before rendering to the output stream.
  • Manipulation : @{ var data= Html.Action(“Action”,”Controller”, new {ParameterName=ParameterValue}); } @data I am Software Developer.
  • Use when data length is small or need to manipulate result before rendering to the output stream.

@Html.RenderAction

  • @Html.RenderAction returns void.
  • Syntax : @{ Html.RenderAction (“Action”,”Controller”); }
  • Pass parameter with RenderAction method Syntax : @{ Html.RenderAction (“Action”,”Controller”, new {ParameterName=ParameterValue});}.
  • It is faster as compared to @Html.Action because this result is written directly to the output stream.
  • It’s result can not be manipulated.
  • Use when data length is large or no need to manipulate result before rendering to the output stream.

@Html.Partial vs @Html.RenderPartial in Asp.Net MVC

@Html.Partial

  • @Html.Partial returns string.
  • Syntax : @Html.Partial(“Partial View Name”).
  • Pass model with Partial method Syntax : @Html.Partial(“Partial View Name”, Model).
  • It is slower as compared to @Html.RenderPartial.
  • It’s result can be manipulated before rendering to the output stream.
  • Manipulation : @{ var data= Html.Partial(“Partial View Name”); } @data I am Software Developer.
  • Use when data length is small or need to manipulate result before rendering to the output stream.

@Html.RenderPartial

  • @Html.RenderPartial returns void.
  • Syntax : @{ Html.RenderPartial(“Partial View Name”); }
  • Pass model with RenderPartial method Syntax : @{ Html.RenderPartial(“Partial View Name”, Model); }
  • It is faster as compared to @Html.Partial because this result is written directly to the output stream.
  • It’s result can not be manipulated.
  • Use when data length is large or no need to manipulate result before rendering to the output stream.

How to call child action method in Asp.Net MVC.

Child action methods can not be called directly. They have to call from inside of a view.
We can make an Action method a child action method by decorating it with [ChildActionOnly] attribute.

[ChildActionOnly]
public ActionResult Child()
{   
    return View();
}


Calling child action method from inside of a view

@Html.Action("Child", "Home")


Where “Child” is the Action method name and “Home” is the controller name.

How to enable Attribute Routing in ASP.NET MVC?

Enabling attribute routing in your ASP.NET MVC5 application is simple, just add a call to routes.MapMvcAttributeRoutes() method with in RegisterRoutes() method of RouteConfig.cs file.

public class RouteConfig 
{ 
    public static void RegisterRoutes(RouteCollection routes) 
    { 
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        //enabling attribute routing 
        routes.MapMvcAttributeRoutes(); 
    } 
}

You can also combine attribute routing with convention-based routing.

public class RouteConfig 
{ 
    public static void RegisterRoutes(RouteCollection routes) 
    { 
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}"); 
        //enabling attribute routing 
        routes.MapMvcAttributeRoutes(); 
        //convention-based routing 
        routes.MapRoute( 
            name: "Default", 
            url: "{controller}/{action}/{id}", 
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }); 
    } 
}

When to use Attribute Routing?

The convention-based routing is complex to support certain URI patterns that are common in RESTful APIs. But by using attribute routing you can define these URI patterns very easily.

For example, resources often contain child resources like Clients have orders, movies have actors, books have authors and so on. It’s natural to create URIs that reflects these relations like as: /clients/1/orders

This type of URI is difficult to create using convention-based routing. Although it can be done, the results don’t scale well if you have many controllers or resource types.

With attribute routing, it’s pretty much easy to define a route for this URI. You simply add an attribute to the controller action as:

[Route("clients/{clientId}/orders")] 
public IEnumerable<Order> GetOrdersByClient(int clientId) 
{ 
  //TO DO 
}

What is Attribute Routing and how to define it?

ASP.NET MVC5 and WEB API 2 supports a new type of routing, called attribute routing. In this routing, attributes are used to define routes. Attribute routing provides you more control over the URIs by defining routes directly on actions and controllers in your ASP.NET MVC application and WEB API.

  • Controller level routing – You can define routes at controller level which apply to all actions within the controller unless a specific route is added to an action.
[RoutePrefix("MyHome")]
[Route("{action=index}")] //default action 
public class HomeController : Controller
{   //new route: /MyHome/Index 
    public ActionResult Index()
    {
        return View();
    } 
    //new route: /MyHome/About 
    public ActionResult About()
    {
        ViewBag.Message = "Your application description page.";
        return View();
    } 
    //new route: /MyHome/Contact 
    public ActionResult Contact()
    {
        ViewBag.Message = "Your contact page.";
        return View();
    }
}
  • Action level routing – You can define routes at action level which apply to a specific action with in the controller.
public class HomeController : Controller
{
    [Route("users/{id:int:min(100)}")] //route: /users/100 
    public ActionResult Index(int id)
    {
        //TO DO: 
        return View();
    }
    [Route("users/about")]  //route" /users/about 
    public ActionResult About()
    {
        ViewBag.Message = "Your application description page.";
        return View();
    }
    //route: /Home/Contact 
    public ActionResult Contact()
    {
        ViewBag.Message = "Your contact page.";
        return View();
    }
}

Note:

  • Attribute routing should configure before the convention-based routing.
  • When you combine attribute routing with convention-based routing, actions which do not have Route attribute for defining attribute-based routing will work according to convention-based routing. In above example Contact action will work according to convention-based routing.
  • When you have only attribute routing, actions which do not have Route attribute for defining attribute-based routing will not be the part of attribute routing. In this way they can’t be access from outside as a URI.

How to define a route in ASP.NET MVC?

You can define a route in ASP.NET MVC as given below:

public static void RegisterRoutes(RouteCollection routes) 
{ 
    routes.MapRoute( "Default", // Route name 
    "{controller}/{action}/{id}", // Route Pattern 
    new { 
            controller = "Home", action = "Index", id = UrlParameter.Optional 
        }// Default values for above defined parameters 
        ); 
} 
protected void Application_Start()
{ 
    RegisterRoutes(RouteTable.Routes); //TODO: 
}

What is Routing in ASP.NET MVC?

Routing is a pattern matching system that monitor the incoming request and figure out what to do with that request. At runtime, Routing engine use the Route table for matching the incoming request’s URL pattern against the URL patterns defined in the Route table. You can register one or more URL patterns to the Route table at Application_Start event.

Routing in ASP.NET MVC

Routing in ASP.NET MVC

When the routing engine finds a match in the route table for the incoming request’s URL, it forwards the request to the appropriate controller and action. If there is no match in the route table for the incoming request’s URL, it returns a 404 HTTP status code.

Explain ASP.NET MVC pipeline?

The detail ASP.NET MVC pipeline is given below:

  1. Routing – Routing is the first step in ASP.NET MVC pipeline. Typically, it is a pattern matching system that matches the incoming request to the registered URL patterns in the Route Table.
    The UrlRoutingModule(System.Web.Routing.UrlRoutingModule) is a class which matches an incoming HTTP request to a registered route pattern in the RouteTable(System.Web.Routing.RouteTable).
  2. Controller Initialization – The MvcHandler initiates the real processing inside ASP.NET MVC pipeline by using ProcessRequest method. This method uses the IControllerFactory instance (default is System.Web.Mvc.DefaultControllerFactory) to create corresponding controller.
    • ASP.Net MVC pipeline

      ASP.Net MVC pipeline

  3. Action Execution – Action execution occurs in the following steps:
    • When the controller is initialized, the controller calls its own InvokeAction() method by passing the details of the chosen action method. This is handled by the IActionInvoker.
    • After chosen of appropriate action method, model binders(default is System.Web.Mvc.DefaultModelBinder) retrieves the data from incoming HTTP request and do the data type conversion, data validation such as required or date format etc. and also take care of input values mapping to that action method parameters.
    • Authentication Filter was introduced with ASP.NET MVC5 that run prior to authorization filter. It is used to authenticate a user. Authentication filter process user credentials in the request and provide a corresponding principal. Prior to ASP.NET MVC5, you use authorization filter for authentication and authorization to a user.
    • By default, Authenticate attribute is used to perform Authentication. You can easily create your own custom authentication filter by implementing IAuthenticationFilter.
    • Authorization filter allow you to perform authorization process for an authenticated user. For example, Role based authorization for users to access resources.
    • By default, Authorize attribute is used to perform authorization. You can also make your own custom authorization filter by implementing IAuthorizationFilter.
    • Action filters are executed before (OnActionExecuting) and after (OnActionExecuted) an action is executed. IActionFilter interface provides you two methods OnActionExecuting and OnActionExecuted methods which will be executed before and after an action gets executed respectively. You can also make your own custom ActionFilters filter by implementing IActionFilter. For more about filters refer this article Understanding ASP.NET MVC Filters and Attributes
    • When action is executed, it process the user inputs with the help of model (Business Model or Data Model) and prepare Action Result.
  4. Result Execution – Result execution occurs in the following steps:
    • Result filters are executed before (OnResultExecuting) and after (OnResultExecuted) the ActionResult is executed. IResultFilter interface provides you two methods OnResultExecuting and OnResultExecuted methods which will be executed before and after an ActionResult gets executed respectively. You can also make your own custom ResultFilters filter by implementing IResultFilter.
    • Action Result is prepared by performing operations on user inputs with the help of BAL or DAL. The Action Result type can be ViewResult, PartialViewResult, RedirectToRouteResult, RedirectResult, ContentResult, JsonResult, FileResult and EmptyResult.
    • Various Result type provided by the ASP.NET MVC can be categorized into two category- ViewResult type and NonViewResult type. The Result type which renders and returns an HTML page to the browser, falls into ViewResult category and other result type which returns only data either in text format, binary format or a JSON format, falls into NonViewResult category.
  5. View Initialization and Rendering – View Initialization and Rendering execution occurs in the following steps:
    • ViewResult type i.e. view and partial view are represented by IView (System.Web.Mvc.IView) interface and rendered by the appropriate View Engine.
    • This process is handled by IViewEngine (System.Web.Mvc.IViewEngine) interface of the view engine. By default ASP.NET MVC provides WebForm and Razor view engines. You can also create your custom engine by using IViewEngine interface and can registered your custom view engine in to your ASP.NET MVC application as shown below:
    • Html Helpers are used to write input fields, create links based on the routes, AJAX-enabled forms, links and much more. Html Helpers are extension methods of the HtmlHelper class and can be further extended very easily. In more complex scenario, it might render a form with client side validation with the help of JavaScript or jQuery.