Asp.Net Mvc Route Constraints Complete Guide

Step 1: Setting Up Your ASP.NET MVC Project

First, create a new ASP.NET MVC project. You can do this via Visual Studio:

1. Open Visual Studio.
2. Click Create a new project.
3. Choose ASP.NET Web Application (.NET Framework).
4. Name your project (e.g., RouteConstraintsExample).
5. Click Create.
6. Select MVC and ensure Add folders and core references for MVC is checked.
7. Click Create again.

Step 2: Understanding Default Routing

Open the RouteConfig.cs file located in the App_Start folder to see the default route setup:

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 }
        );
    }
}

• {controller}: Represents the name of the controller.
• {action}: Represents the name of the action method within the controller.
• {id}: Represents the optional ID parameter.
• defaults: Specifies default values for the URL segments.

Step 3: Adding Basic Route Constraints

Let's add some route constraints to our routing configuration. Open the RouteConfig.cs file and modify it as follows:

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

        // Constraint for id to be an integer
        routes.MapRoute(
            name: "ProductRoute",
            url: "Product/{id}",
            defaults: new { controller = "Product", action = "Details" },
            constraints: new { id = @"\d+" } // Regular expression for numeric values
        );

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

Explanation:

• routes.MapRoute: Defines a new route for the application.
• name: "ProductRoute": Name of the route for reference.
• url: "Product/{id}": URL pattern where {id} is a dynamic segment.
• defaults: Specifies the default controller, action, and any parameters. Here, it points to the Details action in the Product controller.
• constraints: new { id = @"\d+" }: Ensures that the {id} must be a numeric value.

Testing the Route Constraint:

1. Start the application.
2. Navigate to http://localhost:XXXX/Product/123.
   • This should call the Details(int id) action in the ProductController, passing 123 as the id.
3. Navigate to http://localhost:XXXX/Product/abc.
   • This should trigger the default route and navigate to the HomeController's Index action since the id is not numeric.

Step 4: Implementing Multiple Route Constraints

You can also apply multiple constraints to a single route. Here's an example:

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

        // Constraint for id to be an integer and between 1 and 100
        routes.MapRoute(
            name: "ProductLimitedRoute",
            url: "LimitedProduct/{id}",
            defaults: new { controller = "Product", action = "Details" },
            constraints: new { id = @"^[1-9][0-9]?$|^100$" } // Regular expression for numeric values between 1 and 100
        );

        // Constraint for id to be an integer
        routes.MapRoute(
            name: "ProductRoute",
            url: "Product/{id}",
            defaults: new { controller = "Product", action = "Details" },
            constraints: new { id = @"\d+" } // Regular expression for numeric values
        );

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

Explanation:

• ProductLimitedRoute: This route is designed to accept id values between 1 and 100.
• constraints: new { id = @"^[1-9][0-9]?$|^100$" }: Regular expression that matches numbers from 1 to 100.

Testing Multiple Route Constraints:

1. Navigate to http://localhost:XXXX/LimitedProduct/50:
   • This should call the Details(int id) action in the ProductController with id as 50.
2. Navigate to http://localhost:XXXX/LimitedProduct/200:
   • This will not match the ProductLimitedRoute and will fall back to the ProductRoute. If id is not numeric, it will fall back to the default route.
3. Navigate to http://localhost:XXXX/LimitedProduct/abc:
   • Since id is not numeric, it will fall back to the default route, and the HomeController's Index action will be executed.

Step 5: Other Types of Route Constraints

ASP.NET MVC supports various types of route constraints beyond regular expressions. Here are some commonly used ones:

• int: Ensures that the parameter is a 32-bit integer.
• long: Ensures that the parameter is a 64-bit integer.
• float: Ensures that the parameter is a floating-point number.
• decimal: Ensures that the parameter is a decimal number.
• Guid: Ensures that the parameter is a globally unique identifier (GUID).
• bool: Ensures that the parameter is a boolean value.
• min: Specifies the minimum value for numeric parameters.
• max: Specifies the maximum value for numeric parameters.
• range: Specifies a range of values for numeric parameters (syntax: [min,max]).
• minlength: Specifies the minimum length for string parameters.
• maxlength: Specifies the maximum length for string parameters.
• length: Specifies a range of lengths for string parameters (syntax: [min,max]).
• regex: Allows for custom regular expression constraints.

Example of Using Non-Regex Constraints

Let's add a route that ensures id is a long integer and within a specific range:

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

        // Range constraint for long id
        routes.MapRoute(
            name: "ProductRangeRoute",
            url: "RangeProduct/{id}",
            defaults: new { controller = "Product", action = "Details" },
            constraints: new { id = @"long", range = "1,10000" }
        );

        // Constraint for id to be an integer
        routes.MapRoute(
            name: "ProductRoute",
            url: "Product/{id}",
            defaults: new { controller = "Product", action = "Details" },
            constraints: new { id = @"\d+" } // Regular expression for numeric values
        );

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

Explanation:

• id = @"long": Ensures that the id must be a 64-bit integer.
• range = "1,10000": Ensures that the id must be between 1 and 10000.

Testing Non-Regex Constraints:

1. Navigate to http://localhost:XXXX/RangeProduct/5000:
   • This should call the Details(long id) action in the ProductController with id as 5000.
2. Navigate to http://localhost:XXXX/RangeProduct/15000:
   • The value is out of the specified range, so it will fall back to the ProductRoute or default route.
3. Navigate to http://localhost:XXXX/RangeProduct/abc:
   • The value is not a long integer, so it will fall back to the ProductRoute or default route.

Step 6: Creating a Product Controller

To test the routes, create a ProductController with a Details action method:

1. Right-click on the Controllers folder in the Solution Explorer.
2. Select Add > Controller.
3. Choose MVC 5 Controller - Empty.
4. Name it ProductController and click Add.

ProductController.cs

using System;
using System.Web.Mvc;

public class ProductController : Controller
{
    // GET: Product/Details/1
    public ActionResult Details(int id)
    {
        ViewBag.Message = $"Details for product with ID: {id}";
        return View();
    }

    // GET: Product/Details/1 (for the long version)
    public ActionResult Details(long id)
    {
        ViewBag.Message = $"Details for product with ID: {id}";
        return View();
    }
}

Details.cshtml

Create a Details.cshtml view inside the Views/Product folder:

@{
    ViewBag.Title = "Product Details";
}

<h2>@ViewBag.Message</h2>

Step 7: Testing the Routes

Run the application and test different URLs to see how the route constraints work:

1. Product/123:

   • Calls ProductController.Details(int id) with id as 123.
   • Displays: "Details for product with ID: 123"

2. Product/abc:

   • Fallback to the default route.
   • Loads the Home/Index page.

3. LimitedProduct/50:

   • Calls ProductController.Details(int id) with id as 50.
   • Displays: "Details for product with ID: 50"

4. LimitedProduct/200:

   • Falls back to ProductRoute (since 200 is outside the 1-100 range) and calls ProductController.Details(int id) with id as 200.
   • Displays: "Details for product with ID: 200"

5. RangeProduct/5000:

   • Calls ProductController.Details(long id) with id as 5000.
   • Displays: "Details for product with ID: 5000"

6. RangeProduct/15000:

   • Out of the specified range, falls back to ProductRoute or default route.
   • Loads the Home/Index page.

7. RangeProduct/abc:

   • Not a valid long integer, falls back to ProductRoute or default route.
   • Loads the Home/Index page.

Conclusion

By following these steps, you should now have a solid understanding of how to implement and test route constraints in ASP.NET MVC. Route constraints are a powerful feature that allows you to define specific URL patterns and enforce type validation, ensuring that your application handles URLs in a controlled and predictable manner.