O que é FastEndpoints ?
FastEndpoints é uma biblioteca para C# que simplifica a criação de APIs HTTP, oferecendo uma alternativa ao ASP.NET minimal APIs, com uma abordagem mais abstraida e modular.
Quais seriam os benefícios de se utilizar essa biblioteca?
Aqui estão alguns benefícios que seriam adquiridos utilizando essa abordagem.
1. Simplicidade e Menos Código
- O FastEndpoints reduz a quantidade de boilerplate necessária para definir endpoints. Ele permite a definição de endpoints de forma clara e direta, eliminando a necessidade de configurar controllers complexas.
2. Performance Otimizada
- Projetado para ser rápido e leve, FastEndpoints pode melhorar a performance da API, especialmente em cenários de alta demanda, se comparado a abordagens tradicionais com controllers.
3. Rotas e Validações Automáticas
- Ele oferece suporte integrado para validações de entrada e saída através de atributos e injeções automáticas de validação. Isso economiza tempo e garante a consistência nas verificações de dados.
- Rotas também são automaticamente gerenciadas com base na definição dos endpoints, sem a necessidade de escrever manualmente mapeamentos de rotas.
4. Arquitetura de Endpoints Separados
- Em vez de misturar lógica de negócio com roteamento de API, a biblioteca encoraja a separação da lógica de cada endpoint em classes específicas, o que facilita a manutenção e testes de cada endpoint individualmente.
5. Padronização
- FastEndpoints oferece uma maneira de padronizar como endpoints são configurados e implementados. Isso ajuda a manter consistência entre desenvolvedores de equipes maiores e projetos maiores.
6. Baixo Acoplamento
- A biblioteca promove baixo acoplamento, uma vez que a lógica de negócios, validação e configuração de endpoint são claramente separadas em diferentes componentes.
7. Extensibilidade
- Ele é altamente extensível, o que permite que os desenvolvedores criem suas próprias customizações ou usem middlewares do ASP.NET Core. Você ainda tem acesso total ao pipeline de requisições do ASP.NET.
8. Suporte a Dependency Injection
- Como faz parte do ecossistema ASP.NET Core, FastEndpoints suporta facilmente Dependency Injection (injeção de dependência), o que é essencial para criar aplicações modulares e testáveis.
9. Versionamento Simples
- Suporta versionamento de APIs de forma simples, permitindo a criação de diferentes versões de endpoints sem a necessidade de alterar a estrutura do projeto ou criar controladores duplicados.
10. Documentação de API Integrada (OpenAPI/Swagger)
- FastEndpoints oferece suporte nativo para gerar documentação via Swagger ou OpenAPI, facilitando a criação de documentação interativa e o teste dos endpoints.
Quais seriam as desvantagens de se utilizar essa biblioteca?
Embora o FastEndpoints ofereça vários benefícios para o desenvolvimento de APIs em C#, também existem algumas desvantagens a serem consideradas:
1. Comunidade Menor e Suporte Limitado
- Comparado com frameworks mais estabelecidos como o ASP.NET Core MVC, o FastEndpoints tem uma comunidade menor. Isso pode resultar em menos recursos disponíveis, como tutoriais, exemplos e suporte da comunidade.
2. Maturidade e Estabilidade
- Sendo uma biblioteca relativamente nova, pode não ser tão madura ou estável quanto frameworks mais antigos. Isso pode levar a bugs inesperados ou funcionalidades ausentes.
3. Documentação Limitada
- A documentação pode ser menos abrangente ou detalhada, o que pode dificultar o aprendizado e a resolução de problemas específicos.
4. Menos Recursos e Funcionalidades Avançadas
- Pode não oferecer todas as funcionalidades avançadas disponíveis em frameworks mais robustos, como suporte a autenticação complexa, internacionalização ou outras extensões.
5. Integração com Terceiros
- A integração com outras bibliotecas ou ferramentas pode ser mais desafiadora, especialmente se essas ferramentas foram projetadas para funcionar com o ASP.NET Core padrão.
6. Curva de Aprendizado
- Embora vise simplificar o desenvolvimento, os desenvolvedores acostumados com o ASP.NET Core MVC ou outros frameworks podem enfrentar uma curva de aprendizado ao se adaptar às convenções do FastEndpoints.
7. Risco de Dependência de uma Biblioteca Menor
- Depender de uma biblioteca mantida por um grupo menor de desenvolvedores pode representar um risco se o projeto não receber atualizações regulares ou for descontinuado.
8. Flexibilidade Reduzida
- Por ser mais opinativo, o FastEndpoints pode impor certas estruturas e padrões, limitando a flexibilidade para personalizações específicas do projeto.
9. Atualizações e Compatibilidade
- Atualizações futuras podem introduzir mudanças significativas, exigindo tempo e esforço para manter a compatibilidade com versões anteriores.
10. Escalabilidade a Longo Prazo
- Em projetos muito grandes ou complexos, pode haver desafios relacionados à organização e manutenção do código, especialmente se a biblioteca não for otimizada para escalabilidade.
Agora que foram apresentados os prós e contras da biblioteca chegou a hora de criarmos um pequeno projeto para ilustrar como podemos usar essa ferramenta no nosso dia-a-dia.
Para isso vamos seguir o seguinte passo a passo e criar uma API em C# .net 8 na qual irá cadastrar uma nova tarefa e também listar as tarefas cadastradas apenas como demonstração de usabilidade da biblioteca.
Pré-requisitos
- .NET 6 ou superior instalado em sua máquina.
- Um editor de código, como o Visual Studio 2022 ou Visual Studio Code.
Passo 1: Criar um Novo Projeto
Abra o terminal ou prompt de comando e execute o seguinte comando para criar um novo projeto web:
dotnet new web -n TaskApi
Isto criará uma nova pasta chamada TaskApi com um projeto web básico.
Passo 2: Adicionar Dependências do NuGet
Navegue até a pasta do projeto:
cd TaskApi
Adicione os pacotes necessários:
dotnet add package FastEndpoints
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.InMemory
dotnet add package FastEndpoints.Swagger
Nesse caso como é apenas uma demonstração iremos usar o In Memory Cache do Entity Framework que servira como banco de dados relacional enquanto a aplicação estiver rodando.
Passo 3: Criar o Modelo de Dados
Crie uma classe para representar as tarefas. Crie uma pasta chamada Models e dentro dela, crie o arquivo TaskItem.cs:
Models/TaskItem.cs
public class TaskItem
{
public int Id { get; set; }
public string? Title { get; set; }
public bool IsCompleted { get; set; }
}
Passo 4: Configurar o DbContext
Crie uma classe de contexto para o Entity Framework. Crie uma pasta chamada Data e dentro dela, crie o arquivo TaskDbContext.cs:
Data/TaskDbContext.csPasso 4: Configurar o DbContext
Crie uma classe de contexto para o Entity Framework. Crie uma pasta chamada Data e dentro dela, crie o arquivo TaskDbContext.cs:
Data/TaskDbContext.cs
public class TaskDbContext : DbContext
{
public TaskDbContext(DbContextOptions<TaskDbContext> options)
: base(options)
{
}
public DbSet<TaskItem> Tasks { get; set; } = null!;
}
Passo 5: Criar os Endpoints e Requests
Crie uma pasta chamada Endpoints e uma outra pasta chamada Requests e dentro delas, crie os seguintes arquivos: CreateTaskEndpoint.cs e GetTasksEndpoint.cs, na pasta Endpoints e CreateTaskRequest.cs na pasta Requests.
Endpoints/CreateTaskEndpoint.cs
Endpoints/GetTasksEndpoint.cs
Requests/CreateTaskRequest.cs
public class CreateTaskRequest
{
public string? Title { get; set; }
}
public class CreateTaskEndpoint : Endpoint<CreateTaskRequest, TaskItem>
{
private readonly TaskDbContext _dbContext;
public CreateTaskEndpoint(TaskDbContext dbContext)
{
_dbContext = dbContext;
}
public override void Configure()
{
Post(“/tasks”);
AllowAnonymous();
}
public override async Task HandleAsync(CreateTaskRequest req, CancellationToken ct)
{
var taskItem = new TaskItem
{
Title = req.Title,
IsCompleted = false
};
_dbContext.Tasks.Add(taskItem);
await _dbContext.SaveChangesAsync(ct);
await SendAsync(taskItem, cancellation: ct);
}
}
public class GetTasksEndpoint : EndpointWithoutRequest<List<TaskItem>>
{
private readonly TaskDbContext _dbContext;
public GetTasksEndpoint(TaskDbContext dbContext)
{
_dbContext = dbContext;
}
public override void Configure()
{
Get(“/tasks”);
AllowAnonymous();
}
public override async Task HandleAsync(CancellationToken ct)
{
var tasks = await _dbContext.Tasks.ToListAsync(ct);
await SendAsync(tasks, cancellation: ct);
}
}
Passo 6: Configurar o Programa Principal
Abra o arquivo Program.cs e modifique-o para configurar os serviços e o pipeline de middleware:
using FastEndpoints;
using FastEndpoints.Swagger;
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using TaskApi.Data;
var builder = WebApplication.CreateBuilder(args);
// Adicionar serviços ao contêiner.
builder.Services.AddDbContext<TaskDbContext>(options =>
options.UseInMemoryDatabase(“TasksDb”));
// Configurar FastEndpoints
builder.Services.AddFastEndpoints();
// **Registrar o API Explorer**
builder.Services.AddEndpointsApiExplorer();
// Configurar Swagger
builder.Services.AddSwaggerDocument();
var app = builder.Build();
// Configurar o pipeline HTTP
app.UseFastEndpoints();
// Configurar Swagger
app.UseOpenApi();
app.UseSwaggerUi(s => s.ConfigureDefaults());
app.Run();
Passo 7: Executar a Aplicação
No terminal, execute o seguinte comando para iniciar a aplicação:
dotnet run
Verifique a URL retornada e acesse com ctrl + clique do mouse
Digite /swagger em frente a URL para acessar o swagger da aplicação e testar:
preencha o texto com algum titulo de tarefa e execute o endpoint de criação:
Você ira receber um código 200 em caso de sucesso, com as informações da tarefa criada;
Você pode executar o segundo endpoint para listar todas as tarefas criadas:
Com isso terminamos de criar uma API de exemplo utilizando .net 8 como base e também já conseguimos testar o uso do FastEndpoints nessa aplicação, agora vamos dar uma revisada em como isso pode nos ajudar.
Um dos benefícios que posso indicar logo de cara, seria a segregação de endpoints e requests, assim você consegue controlar cada endpoint ao invés de ter uma controller com dezenas de endpoints.
Essa abordagem é ideal para projetos pequenos ou micro serviços, pois vai facilitar no uso do principio de responsabilidade única do SOLID, separando cada endpoint com sua própria responsabilidade.
Aumentando assim a facilidade na manutenção pois as manutenções serão especificas com menor probabilidade de acoplamento de código.
Um ponto negativo dessa abordagem seria a verbosidade que é demandada, uma vez que será necessário escrever mais código.
Considerações Finais
Em suma, o FastEndpoints emerge como uma ferramenta valiosa para desenvolvedores que buscam eficiência e simplicidade na criação de APIs em C#. Ao adotar uma abordagem minimalista e opinativa, ele reduz significativamente o código boilerplate, permitindo que os desenvolvedores foquem na lógica de negócio ao invés de configurações repetitivas. A separação clara entre lógica de negócio e definição de endpoints promove uma arquitetura mais limpa e modular, facilitando a manutenção e escalabilidade do projeto.
Além disso, sua performance otimizada e suporte nativo a recursos como validação automática, versionamento simplificado e documentação integrada via Swagger tornam o desenvolvimento de APIs mais ágil e robusto. A compatibilidade com o ecossistema do ASP.NET Core, incluindo suporte a Dependency Injection e middlewares, garante que os desenvolvedores possam aproveitar o melhor dos dois mundos: a leveza do FastEndpoints e a robustez da plataforma ASP.NET.
Embora seja importante considerar as necessidades específicas de cada projeto e avaliar a maturidade da ferramenta em relação ao ecossistema, o FastEndpoints certamente oferece uma alternativa poderosa para o desenvolvimento rápido e eficiente de APIs RESTful em C#, contribuindo para entregas mais rápidas e código mais sustentável.
Referências
https://fast-endpoints.com/docs/get-started#create-project-install-package