Asp.Net Web Api Attribute Routing Vs Conventional Routing Complete Guide

Overview

Conventional Routing is defined centrally and follows a specific pattern, often set in the WebApiConfig.cs file. Attribute Routing, on the other hand, is more flexible; you can define routes directly on the controller actions using attributes.

Prerequisites

• Visual Studio (2019 or later is recommended)
• Basic knowledge of C# and ASP.NET Web API

Setting Up the Project

1. Create a New ASP.NET Core Web Application:

   • Open Visual Studio and create a new project.
   • Choose ASP.NET Core Web Application.
   • Name your project something like WebApiRoutingExample.

2. Select the API Template:

   • Choose the API template.
   • Ensure that .NET Core or .NET 5/6/7 is selected, depending on your preference.
   • Uncheck Enable Docker Support if you do not need it.

3. Project Structure:

   The default project structure looks like this:

   WebApiRoutingExample/
   │
   ├── Controllers/
   │   └── WeatherForecastController.cs
   │
   ├── Properties/
   │   └── launchSettings.json
   │
   ├── appsettings.json
   ├── Program.cs
   └── WebApiRoutingExample.csproj
   

Conventional Routing

Step 1: Remove Attribute Routes

1. Open WeatherForecastController.cs and remove the [ApiController] and [Route("[controller]")] attributes so that it looks like this:

   using Microsoft.AspNetCore.Mvc;
   
   namespace WebApiRoutingExample.Controllers
   {
       [ApiController]
       public class WeatherForecastController : ControllerBase
       {
           private static readonly string[] Summaries = new[]
           {
               "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
           };
   
           [HttpGet]
           public IEnumerable<WeatherForecast> Get()
           {
               var rng = new Random();
               return Enumerable.Range(1, 5).Select(index => new WeatherForecast
               {
                   Date = DateTime.Now.AddDays(index),
                   TemperatureC = rng.Next(-20, 55),
                   Summary = Summaries[rng.Next(Summaries.Length)]
               })
               .ToArray();
           }
       }
   
       public class WeatherForecast
       {
           public DateTime Date { get; set; }
   
           public int TemperatureC { get; set; }
   
           public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
   
           public string? Summary { get; set; }
       }
   }
   

2. Open Program.cs and add conventional routing inside the WebApplication builder configuration:

   using Microsoft.AspNetCore.Builder;
   using Microsoft.AspNetCore.Hosting;
   using Microsoft.Extensions.Configuration;
   using Microsoft.Extensions.DependencyInjection;
   using Microsoft.Extensions.Hosting;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // Add services to the container.
   builder.Services.AddControllers();
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   if (app.Environment.IsDevelopment())
   {
       app.UseDeveloperExceptionPage();
   }
   
   app.UseHttpsRedirection();
   app.UseAuthorization();
   
   app.UseRouting();
   
   // This is where we define the conventional route
   app.MapControllers();
   
   // Define conventional routing pattern
   app.UseEndpoints(endpoints =>
   {
       endpoints.MapControllerRoute(
           name: "default",
           pattern: "api/{controller=WeatherForecast}/{action=Get}/{id?}");
   });
   
   app.Run();
   

Step 2: Test the Conventional Route

1. Run the application.
2. Open a browser or tools like Postman.
3. Navigate to https://<your-app-url>/api/weatherforecast/get.

You should see the weather forecast JSON response.

Attribute Routing

Step 1: Add Attribute Routing

1. Open WeatherForecastController.cs and add the [ApiController] and [Route("[controller]")] attributes back:

   using Microsoft.AspNetCore.Mvc;
   
   namespace WebApiRoutingExample.Controllers
   {
       [ApiController]
       [Route("[controller]")]
       public class WeatherForecastController : ControllerBase
       {
           private static readonly string[] Summaries = new[]
           {
               "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
           };
   
           [HttpGet]
           public IEnumerable<WeatherForecast> Get()
           {
               var rng = new Random();
               return Enumerable.Range(1, 5).Select(index => new WeatherForecast
               {
                   Date = DateTime.Now.AddDays(index),
                   TemperatureC = rng.Next(-20, 55),
                   Summary = Summaries[rng.Next(Summaries.Length)]
               })
               .ToArray();
           }
   
           [HttpGet("{city}")]
           public IActionResult Get(string city)
           {
               return Ok($"Weather forecast for {city}");
           }
   
           [HttpGet("forecast/{days}")]
           public IActionResult GetForecast(int days)
           {
               return Ok($"Forecast for the next {days} days");
           }
       }
   
       public class WeatherForecast
       {
           public DateTime Date { get; set; }
   
           public int TemperatureC { get; set; }
   
           public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
   
           public string? Summary { get; set; }
       }
   }
   

2. Open Program.cs and ensure that attribute routing is enabled (it is enabled by default with app.UseEndpoints):

   var builder = WebApplication.CreateBuilder(args);
   
   builder.Services.AddControllers();
   
   var app = builder.Build();
   
   if (app.Environment.IsDevelopment())
   {
       app.UseDeveloperExceptionPage();
   }
   
   app.UseHttpsRedirection();
   app.UseAuthorization();
   
   app.UseRouting();
   
   // This enables attribute routing
   app.MapControllers();
   
   app.UseEndpoints(endpoints =>
   {
       // Conventional routing is not needed if you only use attribute routing
       // endpoints.MapControllerRoute(
       //     name: "default",
       //     pattern: "api/{controller=WeatherForecast}/{action=Get}/{id?}");
   });
   
   app.Run();
   

Step 2: Test the Attribute Routes

1. Run the application.

2. Open a browser or Postman and test the following routes:

   • https://<your-app-url>/weatherforecast - This should give you the default weather forecast.
   • https://<your-app-url>/weatherforecast/berlin - This should return "Weather forecast for berlin".
   • https://<your-app-url>/weatherforecast/forecast/3 - This should return "Forecast for the next 3 days".

Comparing Conventional and Attribute Routing

Conventional Routing

• Pros:

  • Centralized routing configuration.
  • Easier to manage multiple controller actions with similar patterns.

• Cons:

  • Can become complex with many controllers and actions.
  • Fixed URL patterns can be restrictive.

Attribute Routing

• Pros:

  • More flexible and granular control over routes.
  • Makes code more readable and maintainable by placing routing logic near the action methods.

• Cons:

  • Can lead to duplication if not managed properly.
  • May result in a larger number of attributes in complex applications.

Summary