In ASP.NET Core MVC, controllers are typically recognized automatically based on the naming convention (e.g., classes ending with Controller
) or by using the [Controller]
attribute.
For example:
[Controller]
public class HomeController : Controller
{
// Action methods
}
However, I conducted an experiment where I removed the naming convention and the [Controller]
attribute:
public class Home : Controller
{
// Action methods
}
Despite these changes, app.MapControllers()
still recognized Home
as a controller and routed requests to it.
Program.cs
:
var builder = WebApplication.CreateBuilder(args);
// Add service class (reusable classes)
// Registers all classes ending with "Controller" as MVC controllers.
builder.Services.AddControllers();
var app = builder.Build();
// Detects all controllers, maps their action methods to routes,
// and sets up routing for each action method.
app.MapControllers();
app.Run();
HomeController
:
using Microsoft.AspNetCore.Mvc;
namespace ControllersExample.Controllers
{
public class Home : Controller
{
// Attribute routing
[Route("/home")]
[Route("/")]
public string Index()
{
return " Hello from index";
}
// Attribute routing
[Route("/about")]
public string About()
{
return " Hello from about";
}
// Attribute routing
[Route("/contact/{mobile:regex(^\\d{{10}}$)}")]
public string Contact()
{
return " Hello from contact";
}
}
}
My questions are
Home
to be recognized as a controller even though it doesn’t follow the default naming convention or have the [Controller]
attribute?Additional context:
Any insights or explanations would be greatly appreciated!
In ASP.NET Core MVC, a class is recognized as a controller based on several factors. Even if you remove the conventional naming suffix (Controller) and the [Controller] attribute, the class can still be recognized as a controller due to inheritance from specific base classes.
Here’s why:
The Controller class in ASP.NET Core MVC inherits from ControllerBase, which has the [Controller] attribute applied to it. This attribute is used to identify that the class is a controller. As a result, any class that inherits from Controller or ControllerBase is automatically treated as a controller by the framework.
public class Home : Controller
{
// Action methods
}
In this case, Home inherits from Controller, and Controller inherits from ControllerBase, which carries the [Controller] attribute. This inheritance chain is sufficient for the framework to recognize Home as a controller.
Even if the class does not follow the default naming convention (*Controller), the ASP.NET Core MVC framework still recognizes it because the inheritance from Controller provides the necessary metadata. The [Controller] attribute applied to ControllerBase is part of this metadata.
Although you’re relying on default behavior here, if you had removed the inheritance from Controller or ControllerBase, and did not follow naming conventions or use the [Controller] attribute, the class would no longer be automatically recognized as a controller. In such cases, you would need to manually configure or register the controller, typically through custom conventions or by explicitly adding it to the service collection.