What is MapGroup in Minimal API?

Introduction

Minimal APIs in .NET Core provide a lightweight approach to building HTTP APIs. Introduced in .NET 6 and enhanced in later versions, they allow you to define routes and handle HTTP requests with minimal boilerplate. One powerful feature of Minimal APIs is MapGroup, which helps organize and structure your API routes efficiently.

In this article, we’ll explore.

What is MapGroup?
Benefits of using MapGroup.
Pros and cons.
When and why to use MapGroup.
A practical example to showcase its use.

What is MapGroup?

MapGroup is a feature in Minimal APIs that allows you to group related endpoints together under a common route prefix and configuration. It helps in organizing endpoints logically, making your codebase more readable and maintainable.

Mapping ground in a Minimal API refers to the process of defining routes and handling requests in a streamlined manner, leveraging the simplicity of .NET's Minimal APIs. This approach allows developers to create lightweight web applications with less boilerplate code, enhancing productivity.

Example: Traditional vs. MapGroup

Without MapGroup

var app = builder.Build();

app.MapGet("/users", () => "List of users");
app.MapGet("/users/{id}", (int id) => $"User details for {id}");
app.MapPost("/users", () => "Create a new user");

app.Run();

With MapGroup

var app = builder.Build();

var usersGroup = app.MapGroup("/users");

usersGroup.MapGet("/", () => "List of users");
usersGroup.MapGet("/{id}", (int id) => $"User details for {id}");
usersGroup.MapPost("/", () => "Create a new user");

app.Run();

By using MapGroup, all endpoints under /users are grouped together, improving organization and scalability.

Key Features of MapGroup

Route Prefixing: Automatically applies a common prefix to all endpoints within the group.
Shared Middleware: Apply middleware like authentication or logging to all endpoints in a group.
Logical Organization: Separate concerns by grouping related endpoints (e.g., /users, /orders).

Practical Example

Here’s a complete example of using MapGroup with additional configurations.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Users Group
var usersGroup = app.MapGroup("/users")
                    .RequireAuthorization()
                    .WithOpenApi();

usersGroup.MapGet("/", () => "List of users");
usersGroup.MapGet("/{id:int}", (int id) => $"User details for {id}");
usersGroup.MapPost("/", () => "Create a new user");

// Orders Group
var ordersGroup = app.MapGroup("/orders")
                     .AddEndpointFilter(async (context, next) =>
                     {
                         // Example filter logic
                         Console.WriteLine("Processing order request");
                         return await next(context);
                     });

ordersGroup.MapGet("/", () => "List of orders");
ordersGroup.MapPost("/", () => "Create a new order");

app.Run();

Benefits of MapGroup

Clean Code Organization: MapGroup enables logical grouping of related routes, reducing clutter in your Program.cs file.
Shared Middleware: Apply middleware like authorization, logging, or custom filters to an entire group instead of individual endpoints.
Route Consistency: It automatically adds a common prefix to all routes, avoiding duplication and potential errors.
Scalability: As your API grows, you can easily manage and extend endpoint groups without impacting unrelated routes.
Enhanced Maintainability: Improves the readability of your codebase, making it easier for teams to collaborate and manage.
Simplicity: Minimal APIs reduce the complexity of setting up a web server.
Performance: They are lightweight, leading to faster response times.
Flexibility: Easy to modify and extend as requirements change.

Pros and Cons

Pros

Simplifies route definitions.
Reduces code duplication for common configurations.
Works seamlessly with middleware and filters.
Enhances readability and maintainability.
Less code to manage.
Quick to set up and deploy.
Ideal for microservices and small applications.

Cons

Only available in the Minimal API approach.
Teams accustomed to traditional controllers may face a learning curve.
Misconfiguration in a group could affect multiple endpoints.
Limited features compared to full-fledged frameworks.
May not be suitable for large applications requiring extensive routing and middleware.

When and Why to Use MapGroup?

When to Use

Consider using Minimal APIs when developing small to medium-sized applications, microservices, or when rapid prototyping is needed. They are particularly beneficial when you want to focus on specific functionalities without the overhead of a traditional MVC framework.

You’re building an API with Minimal APIs and need to manage multiple related routes.
You want to apply common configurations, such as authentication, to a set of routes.
Your project requires scalability, with endpoints logically organized by feature or resource.

Why Use

To keep your Program.cs file manageable as your API grows.
To improve the readability and structure of your Minimal API.
To enforce consistency in route prefixes and middleware usage.

mapping ground in Minimal API is a powerful approach for developers looking to create efficient and straightforward web applications in .NET.