Dotnet 7.0 Minimal API Architecture

Architecture to create minimal APIs in .NET7:

---

What is minimal APIs?
Benefits of using Minimal APIs over controllers 
Some common misunderstandings about minimal APIs 
The architecture of Minimal APIs for a large-scale project (same like controllers)

What is minimal APIs?

---

Benefits of using Minimal APIs over controllers:

---

More verbose: Controllers often need to do more than just pass data between the client and the server. For example, they may also need to do things like authenticate users, validate input, and generate error messages. This can make controllers more verbose than minimal APIs, which are typically just a few lines of code.

[HttpGet]
public IActionResult GetEmployees()
{
   return Ok(db.Employees.ToList());
}

app.MapGet("/employees", () => db.Employees.ToList());

Less flexible: Controllers are often designed to work with a specific set of data or operations. This can make them less flexible than minimal APIs, which can be used for a wider variety of tasks.

Difficult to test: Controllers often depend on other parts of the application, such as the database or the user interface. This can make them more difficult to test in isolation.

Difficult to maintain. Controllers can become complex and difficult to understand over time. This can make them more difficult to maintain and update.

Some common misunderstandings about minimal APIs :

---

Not a full-featured web framework: Minimal API is a lightweight framework that provides the bare essentials for building RESTful APIs. This means that it does not include features such as routing, dependency injection, or validation. These features can be added as needed, but they are not included by default.

Not suitable for large or complex projects: This is another common misunderstanding about Minimal API. While it is true that Minimal API is not a good choice for all projects, it can be used for large and complex projects as well. In fact, some large and complex projects have been built using Minimal API.

Difficult to learn and use: This is a misconception that is often perpetuated by people who have not actually used Minimal API. In reality, Minimal API is actually quite easy to learn and use. The code is concise and easy to read, and there are many resources available to help developers get started.

Minimal API is not secure: This is another misconception that is not entirely accurate. Minimal API is secure by default because it uses HTTPS and other security features to protect data. However, it is important to use security best practices when developing Minimal API applications.

Everything in one file called Program.cs: One thing that people are getting mixed up about is where to put all the code for their website. Some folks think that they have to put everything in one file called Program.cs. But actually, there’s a better way to do it using something called “extension methods.”

The architecture of Minimal APIs for large scale project (same as controllers):

---

Setting Up the Application
Extending the WebApplication
Creating Ping Endpoints
Creating Weather Forecast Endpoints
Simplifying Endpoint Registration
Defining Model Classes
Understanding ResultsWrapper and RouteGroupBuilderExtensions

Our project structure is look like this:

---

Step 1: Setting Up the Application:

---

using SampleMinimalAPI.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.RegisterEndpoints();
app.UseHttpsRedirection();

app.Run();

Explanation:

The builder is used to build the application.
If the application is in the development environment, Swagger and SwaggerUI are enabled. Swagger helps document the API endpoints.
The RegisterEndpoints() method is called to register the API endpoints. Will explain into Step 2 in this blog about this method in details.

Step 2: Extending The WebApplication:

---

using SampleMinimalAPI.Endpoints;

namespace SampleMinimalAPI.Extensions;

public static class WebApplicationExtensions
{
    public static void RegisterEndpoints(this WebApplication application)
    {
        var globalGroupV1 = application.MapGroup("api");

        PingEndpoints.Endpoints(globalGroupV1);
        WeatherForcastEndpoints.Endpoints(globalGroupV1);
    }
}

Explanation:

An extension method RegisterEndpoints is defined for the WebApplication class to make endpoint registration more organized.
A global group named “api” is created using MapGroup.
The PingEndpoints and WeatherForcastEndpoints are registered under the “api” group.

Step 3: Creating Ping Endpoints:

---

using SampleMinimalAPI.Extensions;
using SampleMinimalAPI.Models;
using SampleMinimalAPI.Wrappers;

namespace SampleMinimalAPI.Endpoints;

public class PingEndpoints
{
    public static void Endpoints(RouteGroupBuilder builder)
    {
        var group = builder.MapGroup("ping");

        group.GetAnonymous("ping", PingV1)
            .AddMetaDataAnonymous<PingInfo>();



    }

    internal static IResult PingV1()
    {   
        // ... code to handle ping request and log the response 

        return ResultsWrapper.Ok(pingInfo);

    }
}

Explanation:

The PingEndpoints class defines a static method Endpoints that registers ping endpoints.
A group named “ping” is created using MapGroup.
An anonymous GET endpoint named “ping” is added to the “ping” group.
The PingV1 method handles the logic for the ping request. It logs a response and returns an “OK” result with ping information.

Step 4: Creating Weather Forecast Endpoints:

---

using SampleMinimalAPI.Extensions;
using SampleMinimalAPI.Models;
using SampleMinimalAPI.Wrappers;

namespace SampleMinimalAPI.Endpoints;

public static class WeatherForcastEndpoints
{
    public static void Endpoints(RouteGroupBuilder builder)
    {
        var group = builder.MapGroup("weather");

        group.GetAnonymous("weatherforecast", GetWeatherForecast)
            .AddMetaDataAnonymous<PingInfo>();
    }

    internal static IResult GetWeatherForecast()
    {
        // ... code to generate weather forecast data ...

        return ResultsWrapper.Ok(forecast);
    }
}

Explanation:

The WeatherForcastEndpoints class defines a static method Endpoints that registers weather forecast endpoints.
A group named “weather” is created using MapGroup.
An anonymous GET endpoint named “weatherforecast” is added to the “weather” group.
The GetWeatherForecast method generates weather forecast data and returns an “Ok” result with the forecast.

Step 5: Simplifying Endpoint Registration:

---

namespace SampleMinimalAPI.Extensions;
public static class RouteGroupBuilderExtensions
{
	public static RouteHandlerBuilder Get(this RouteGroupBuilder webApplication, string route, Delegate action, string routeName = null)
	{
    	// ... logic to register a GET route ...
	}

	// ... similar extension methods for POST, PUT, DELETE, and anonymous routes ...
}

Explanation:

Extension methods are defined to add common HTTP routes using MapGet, MapPost, MapPut, and MapDelete.
There are also extension methods for anonymous routes.
These methods make endpoint registration more concise and readable.

Step 6: Defining Model Classes:

---

APIResponseBase is a generic class for API responses, including status code, success status, message, and result.
PingInfo represents the response data for the ping endpoint.
WeatherForecast is a record that represents weather forecast data.

Step 7: Understanding ResultsWrapper and RouteGroupBuilderExtensions:

---

ResultsWrapper is a utility that simplifies the creation of API responses by wrapping the data in a standardized format, including status codes and success flags.
RouteGroupBuilderExtensions provides convenient extension methods to register different types of routes (GET, POST, PUT, DELETE) and anonymous routes. These methods enhance readability and reduce redundancy when registering endpoints.

Do You Need more information?

For any further information / query regarding Technology, please email us at info@varianceinfotech.in
OR call us on +1 630 534 0223 / +91-7016851729, Alternately you can request for information by filling up Contact Us