Asp.Net Mvc Routeconfig And Routing Mechanism Complete Guide

What is Routing in ASP.NET MVC?

Routing in ASP.NET MVC controls how incoming URL requests are mapped to particular Controller actions. It helps make sure that the URLs that users enter in the browser address bar are sent to the correct controller and action method.

Step 1: Create an ASP.NET MVC Project

First, you need to create a new ASP.NET MVC application:

1. Open Visual Studio (make sure it has .NET Framework SDK or .NET Core SDK).
2. Go to File > New > Project.
3. Choose ASP.NET Web Application (.NET Framework). If you are working with ASP.NET Core, you can choose ASP.NET Core Web Application.
4. Enter a project name like MvcRouteExamples.
5. Click OK.
6. In the next dialog, choose MVC as the application type and click Create.

Step 2: Understanding Default Routing Configuration

When you create a new ASP.NET MVC application, there will be a default route configuration set up for you in the RouteConfig.cs file located in the App_Start folder.

Here is what the default routing looks like:

using System.Web.Mvc;
using System.Web.Routing;

namespace MvcRouteExamples
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

Explanation of Default Routing Configuration

• routes.IgnoreRoute("{resource}.axd/{*pathInfo}");: This tells the router to ignore requests for resources like .axd files which are served directly by IIS.
• routes.MapRoute(): Maps a URL pattern to a route handler, which usually selects a controller and action method.
  • name: "Default": This is just the name of the route, you can change it.
  • url: "{controller}/{action}/{id}": This defines the URL pattern, where {controller}, {action}, and {id} are placeholders.
  • defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }: Specifies default values for the pattern.

Step 3: Modify the RouteConfig

Let's add a few custom routes to see how routing works.

Example: Adding a Custom Route

We'll define a new route that handles URLs like Blog/Article/{articleID}.

Edit the RouteConfig.cs file to include this custom route:

using System.Web.Mvc;
using System.Web.Routing;

namespace MvcRouteExamples
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Blog route
            routes.MapRoute(
                name: "BlogArticle",
                url: "Blog/Article/{articleID}",
                defaults: new { controller = "Blog", action = "Article", articleID = UrlParameter.Optional }
            );

            // Default route
            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

Example: Adding Another Custom Route

Now, let's create another custom route for URLs like User/Profile/{userID}.

Edit the RouteConfig.cs file:

using System.Web.Mvc;
using System.Web.Routing;

namespace MvcRouteExamples
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // User profile route
            routes.MapRoute(
                name: "UserProfile",
                url: "User/Profile/{userID}",
                defaults: new { controller = "User", action = "Profile", userID = UrlParameter.Optional }
            );

            // Blog route
            routes.MapRoute(
                name: "BlogArticle",
                url: "Blog/Article/{articleID}",
                defaults: new { controller = "Blog", action = "Article", articleID = UrlParameter.Optional }
            );

            // Default route
            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

Step 4: Define Controllers

For these new routes to work, you'll need to add corresponding controllers and action methods.

Creating BlogController

Add a controller called BlogController:

1. Right-click on the Controllers folder in the Solution Explorer.
2. Select Add > Controller....
3. Select the empty controller template (MVC 5 Controller - Empty).
4. Name your controller BlogController.
5. Click on Add.

After adding the BlogController, modify the action method like below:

using System.Web.Mvc;

namespace MvcRouteExamples.Controllers
{
    public class BlogController : Controller
    {
        // GET: Blog/Article/{articleID}
        public ActionResult Article(int? articleID)
        {
            if (articleID.HasValue)
            {
                ViewBag.ArticleID = articleID.Value;
            }
            else
            {
                ViewBag.Message = "No article ID specified.";
            }
            return View();
        }
    }
}

Create an Article.cshtml view under Views/Blog.

@{
    ViewBag.Title = "Article";
}

<h2>@ViewBag.Message</h2>
<p>Article ID: @ViewBag.ArticleID</p>

Creating UserController

Following the same procedure to add UserController:

using System.Web.Mvc;

namespace MvcRouteExamples.Controllers
{
    public class UserController : Controller
    {
        // GET: User/Profile/{userID}
        public ActionResult Profile(int? userID)
        {
            if (userID.HasValue)
            {
                ViewBag.UserID = userID.Value;
            }
            else
            {
                ViewBag.Message = "No user ID specified.";
            }
            return View();
        }
    }
}

And create a Profile.cshtml view under Views/User.

@{
    ViewBag.Title = "Profile";
}

<h2>@ViewBag.Message</h2>
<p>User ID: @ViewBag.UserID</p>

Step 5: Test the Routes

Now, we can test our routes:

• Start the application by hitting F5. It should open the default home page.
• In the browser, navigate to /Blog/Article/101. The BlogController's Article action should handle this request and display the view with Article ID: 101.
• Navigate to /User/Profile/202. The UserController's Profile action should handle this request and display the view with User ID: 202.

If you navigate to /Blog/Article/ without providing an articleID, the Article action method would still run using the default value, and you would see the message "No article ID specified."

Similarly, if you navigate to /User/Profile/ without providing a userID, you would see the message "No user ID specified."

Step 6: Understanding How Routing Works

The routing system in ASP.NET MVC processes URL patterns from top to bottom in the RouteConfig file. When a request comes in, MVC tries to match the URL against the patterns defined in the RouteConfig file. If a match is found, the request is processed by the controller and action specified in the defaults. If no match is found, MVC continues checking the next patterns until it either finds a match or exhausts all patterns.

Additional Notes

• Route Order Matters: Since routes are checked from top to bottom, more specific routes should come before more general routes.
• Optional and Required Parameters: You can define routes with optional, required, and even parameter constraints. For example, {articleID:int} would require articleID to be an int.
• Route Constraints: You can apply constraints to route parameters to limit what values they can accept such as integer, string length, regular expression matches, etc.

Summary

In this step-by-step guide, we learned how to define custom routes in ASP.NET MVC using the RouteConfig class and tested these routes by creating appropriate controllers and views. Understanding and configuring routes is crucial for creating clean, organized URLs that match the needs of your application.