Minimal APIs or Controllers in ASP.NET Core

Introduction

.NET has evolved significantly over the last 5 to 6 years. Building applications like MVC or APIs (Application Programming Interfaces) is now easier than ever before. ASP.NET Core 6 introduces the Minimal APIs feature, which simplifies API development by removing the need to create controllers, which traditionally sit at the front of APIs. Now, .NET supports two approaches: Controllers (the old way) and Minimal APIs (the new way). But which one should you use?

What are Minimal APIs?

Minimal APIs define endpoints as logical handlers using lambdas or methods. They utilize method injection for services, while controllers use constructor or property injection. In Minimal APIs, each endpoint only requires the specific services it needs. This is in contrast to controllers, where all endpoints within the controller use the same class constructor, which can make the controller "fat" as it grows. Minimal APIs are designed to hide the host class by default and emphasize configuration and extensibility via extension methods that take lambda expressions.

Here is an example of minimal API.

app.MapGet("/weatherforecast", (HttpContext httpContext) =>
{
    var forecast = Enumerable.Range(1, 5).Select(index => 
        new WeatherForecast
        {
            Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = summaries[Random.Shared.Next(summaries.Length)]
        })
        .ToArray();

    return forecast;
});

Here are the important points that we should know before jumping into the minimal API. These points are from the Microsoft docs.

Minimal APIs lack built-in support for,

• Model binding (IModelBinderProvider, IModelBinder). However, support can be added via custom binding shims.
• Validation (IModelValidator).
• Application parts or the application model. There is no way to apply or build your conventions.
• View rendering. For this, it is recommended to use Razor Pages.
• JsonPatch.
• OData.

You can work around these limitations by implementing custom solutions for each of these missing features.

Conclusion

Minimal APIs are an excellent way to start building APIs. One practical use case for Minimal APIs is in Vertical Slice Architecture (Vertical Slice Architecture is a design approach where features are implemented end-to-end, encapsulating all layers (UI, business logic, and data access) within self-contained slices.). In this approach, you can define endpoints for each module separately, making management easier. Since each endpoint in Minimal APIs declares the specific services it needs, this approach helps avoid the issue of controller classes becoming "fat" as they grow and more endpoints are added.

For me, minimal APIs are good to go for small-scale projects and they are easy to handle when endpoints grow.