How to use FastEndpoints in ASP.NET Core

This tool offers an alternative to traditional ASP.NET Core API development methods, including MVC controllers and minimal APIs.

In this guide, we will explore how to use FastEndpoints to create efficient APIs in ASP.NET Core, combining the benefits of both traditional controllers and minimal APIs.

API Development Options in ASP.NET Core

ASP.NET Core provides two primary ways to build APIs:

• Traditional Controllers: These, including MVC and API controllers, offer a feature-rich environment but come with a lot of boilerplate code and reduced performance compared to minimal APIs.
• Minimal APIs: Designed for speed and simplicity, minimal APIs minimize code but sacrifice some features like model binding, validation, and others.

FastEndpoints serves as a middle ground, delivering features such as model binding, rate limiting, and caching while maintaining a high level of performance. Unlike minimal APIs, FastEndpoints also allows for integration with Swagger or OpenAPI for better documentation.

Understanding FastEndpoints

FastEndpoints is built around the REPR (Request-Endpoint-Response) design pattern, which simplifies API development by organizing code into distinct layers: requests, logic, and responses.

Setting Up FastEndpoints in an ASP.NET Core Application

To use FastEndpoints, start by installing the FastEndpoints NuGet package into your project. You can do this via the NuGet Package Manager or with the following command in the NuGet Package Manager Console:

PM> Install-Package FastEndpoints

Register FastEndpoints in Program.cs

Next, you need to add the FastEndpoints service to the ASP.NET Core application’s service collection in the Program.cs file. Include the following line of code:

builder.Services.AddFastEndpoints();

If your project name is on the FastEndpoints exclusion list, manually specify the assemblies to avoid runtime exceptions:

builder.Services.AddFastEndpoints(
    o => o.Assemblies = new[] { typeof(YourRequestClass).Assembly }
);

Creating the Request and Response DTOs

Now, let’s define the data transfer objects (DTOs) for both the request and response.

Request DTO:

public class CreateUserRequest
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Response DTO:

public class CreateUserResponse
{
    public string Message { get; set; }
}

Define the Endpoint Class

The core of FastEndpoints is the Endpoint class, where you define how requests are processed and responses are generated.

using FastEndpoints;

public class CreateUserEndpoint : Endpoint<CreateUserRequest, CreateUserResponse>
{
    public override void Configure()
    {
        Post("/api/user/create");
        AllowAnonymous(); // Open endpoint
    }

    public override async Task HandleAsync(CreateUserRequest request, CancellationToken token)
    {
        var response = new CreateUserResponse
        {
            Message = $"User {request.FirstName} {request.LastName} created successfully."
        };
        await SendAsync(response);
    }
}

Ensure that FastEndpoints is correctly wired into the application by adding the following code to Program.cs:

using FastEndpoints;

var builder = WebApplication.CreateBuilder();
builder.Services.AddFastEndpoints();

var app = builder.Build();
app.UseFastEndpoints(); // Enables FastEndpoints middleware

app.Run();

Testing the Endpoint

Now, run your application and test it using a tool like Postman. Send a POST request with the following JSON body to the /api/user/create endpoint:

{
    "FirstName": "John",
    "LastName": "Doe"
}

You should receive a response like:

{
    "Message": "User John Doe created successfully."
}

FastEndpoints offers a compelling alternative to traditional API development in ASP.NET Core. It balances performance with features, providing a structured approach to building lean, efficient APIs without the overhead of MVC controllers.