A lightweight method for creating HTTP APIs is offered by.NET Core's minimal APIs. They were first introduced in.NET 6 and improved in subsequent iterations, enabling you to process HTTP requests and construct routes with less boilerplate. MapGroup is a potent component of Minimal APIs that facilitates effective route organization and structuring.

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.