ASP.NET Core MVC: How Is a Controller Recognized Without Following the Default Naming Convention or Using [Controller] Attribute?

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

• How is it possible for Home to be recognized as a controller even though it doesn’t follow the default naming convention or have the [Controller] attribute?
• Are there any default or implicit conventions in ASP.NET Core MVC that might explain this behavior?

Additional context:

• I am using ASP.NET Core version 8.
• I did not apply any custom conventions or configurations beyond the default setup.

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:

1. Inheritance from Controller or ControllerBase:

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.

2. Default Convention Handling:

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.

3. Custom Configuration:

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.