Routing Mechanism In Asp.Net Core Complete Guide

Step-by-Step Guide: Routing Mechanism in ASP.NET Core

Step 1: Create a New ASP.NET Core Project

First, let's create a new ASP.NET Core Web API project. This will give us a basic setup where we can focus on routing.

1. Open your terminal or command prompt.

2. Run the following command to create a new project:

   dotnet new webapi -n RoutingDemo
   cd RoutingDemo
   

3. Run the project to ensure everything is set up correctly:

   dotnet run
   

   You should see output indicating that the application is running and you can access it via http://localhost:5000.

Step 2: Understanding Default Routing

In an ASP.NET Core Web API application, the default routing setup typically involves attribute routing and convention-based routing. Let's explore the default conventions.

1. Open Controllers/WeatherForecastController.cs.
2. Look at the [ApiController] and [Route("api/[controller]")] attributes:

   [ApiController]
   [Route("api/[controller]")]
   public class WeatherForecastController : ControllerBase
   {
       // Controller endpoints here
   }
   

   In this context:
   • [ApiController] enables several useful features like automatic model validation.
   • [Route("api/[controller]")] means the route will dynamically be api/weatherforecast.

Step 3: Adding a Simple Convention-Based Route

Let's add a simple convention-based route that follows the default pattern but modifies the Get method.

1. Add a new method GetCurrentTemperature inside WeatherForecastController.cs:

   [HttpGet("{city}")]
   public IActionResult GetCurrentTemperature(string city)
   {
       var temperature = GetTemperatureForCity(city);
       return Ok($"The current temperature in {city} is {temperature}°C");
   }
   
   private int GetTemperatureForCity(string city)
   {
       // Example logic to get temperature based on city
       switch (city.ToLower())
       {
           case "london":
               return 5;
           case "new york":
               return 10;
           case "tokyo":
               return 15;
           default:
               return 0;
       }
   }
   

   Here the Get verb and {city} in [HttpGet("{city}")] mean:

   • We can access this endpoint via a URL like http://localhost:5000/api/weatherforecast/london.

2. Test the endpoint: Use a tool like Postman or your browser to navigate to http://localhost:5000/api/weatherforecast/london. You should see something like: "The current temperature in london is 5°C".

Step 4: Adding Attribute-Routed Method

Attribute routing provides more flexibility and precision compared to convention-based routing. Next, let's add an attribute-routed method.

1. Still inside WeatherForecastController.cs, add the following GetPopulationByCity method:

   [Route("population/{city}")]
   [HttpGet]
   public IActionResult GetPopulationByCity(string city)
   {
       var population = GetPopulationForCity(city);
       return Ok($"The population of {city} is {population}");
   }
   
   private int GetPopulationForCity(string city)
   {
       // Example logic to get population based on city
       switch (city.ToLower())
       {
           case "london":
               return 8900000;
           case "new york":
               return 8400000;
           case "tokyo":
               return 13929000;
           default:
               return 0;
       }
   }
   

2. Test the endpoint: Navigate to http://localhost:5000/api/weatherforecast/population/london. You should see something like: "The population of london is 8900000".

Step 5: Setting Up Global Routes

For global routing settings, you typically modify the Startup.cs file’s configure method.

1. Open Program.cs (if you are using .NET 6 or later) or Startup.cs if you are using an earlier version.

2. Find the app.UseEndpoints middleware and add a global route:

   app.MapGet("/global/{city}", (string city) =>
   {
       var temperature = GetTemperatureForCity(city);
       return $"Global Route: The current temperature in {city} is {temperature}°C";
   });
   

   If you are using .NET 5 or earlier, it would be in the Configure method:

   endpoints.MapGet("/global/{city}", (string city) =>
   {
       var temperature = GetTemperatureForCity(city);
       return $"Global Route: The current temperature in {city} is {temperature}°C";
   });
   

3. Test the endpoint: Navigate to http://localhost:5000/global/london. You should see something like: "Global Route: The current temperature in london is 5°C".

Step 6: Advanced Routing with Constraint

Constraints add more control over what types of request parameters are allowed in the URL.

1. Modify the GetCurrentTemperature method to include a numeric constraint for an additional parameter year:

   [HttpGet("{city}/{int:year}")]
   public IActionResult GetCurrentTemperature(string city, int year)
   {
       var temperature = GetTemperatureForCity(city);
       return Ok($"The current temperature in {city} in {year} is {temperature}°C");
   }
   

2. Test the endpoint: Navigate to http://localhost:5000/api/weatherforecast/london/2023. You should see output similar to before but include the year in the message.

Step 7: Named Routes

Named routes make it easier to generate URLs in your app without hardcoding them.

1. Modify the GetCurrentTemperature method again to add a name to the route:

   [HttpGet("{city}/{int:year}", Name = "GetCurrentTemperature")]
   public IActionResult GetCurrentTemperature(string city, int year)
   {
       var temperature = GetTemperatureForCity(city);
       var message = $"The current temperature in {city} in {year} is {temperature}°C";
   
       // Optionally returning a Created result to show named route usage
       return CreatedAtRoute("GetCurrentTemperature", new { city = city, year = year }, message);
   }
   

2. Test the endpoint: Navigate to http://localhost:5000/api/weatherforecast/london/2023. You should see the response as usual, but in real scenarios, the named route helps when creating links in responses.

Conclusion

In this guide, we've covered the basics of routing mechanisms in ASP.NET Core by creating a sample project, adding conventional routes, utilizing attribute routing, setting up global routes, incorporating constraints, and using named routes. This knowledge will help you design better APIs with more flexible and precise routing.