Explorando o Carter: Um Framework Simples e Eficaz para APIs em .NET
Published: 2023-11-23 12:32:46

Nos últimos anos, o desenvolvimento de APIs em .NET tem evoluído significativamente. Frameworks e bibliotecas surgiram para simplificar o processo de criação de APIs RESTful e fornecer maneiras mais eficientes de lidar com solicitações HTTP. Um desses frameworks é o Carter, uma biblioteca minimalista, mas poderosa, para criação de APIs em ASP.NET Core. Neste artigo, exploraremos o que é o Carter, suas vantagens e como começar a usá-lo em seus projetos.

Recentemente fiz uma contribuição para o projeto, permitindo definir o tempo de vida dos registros dos validadores do FluentValidation, que por padrão são registrados como Singleton. Esse ajuste permitiu que o validadores que tenham dependências diferentes de Singleton pudessem ser utilizadas pelo Carter evitando erros de registro.

## O que é o Carter?

O Carter é um framework para desenvolvimento de APIs em ASP.NET Core que se destaca por sua simplicidade e eficácia. Ele permite que você defina rotas e manipuladores de solicitações HTTP de maneira elegante e direta, sem a necessidade de controladores complexos. 

## Vantagens do Carter

O Carter oferece várias vantagens que podem ser atraentes para desenvolvedores que desejam criar APIs em .NET de maneira eficiente:

### 1. Sintaxe Simples e Declarativa

Uma das principais vantagens do Carter é sua sintaxe simples e declarativa. Você define rotas e manipuladores em um estilo fácil de ler, tornando seu código mais legível e compreensível.

```csharp
using Carter;
using Carter.OpenApi;

namespace DemoCarter;

public class Module : CarterModule
{
    public Module()
    {
        WithTags("Module");
    }
    public override void AddRoutes(IEndpointRouteBuilder app)
    {
        app.MapGet("/", () =>
        {
            return "Hello Carter!";
        })
        .IncludeInOpenApi()
        .RequireAuthorization();
    }
}
```

### 2. Independência de Controladores

Diferentemente do ASP.NET Core MVC, que depende de controladores para lidar com as solicitações, o Carter não requer controladores. Isso pode simplificar a estrutura do seu projeto, tornando-o mais direto e muito útil em aplicações com minimal APIs.

### 3. Baixo Acoplamento

O Carter promove o baixo acoplamento entre os componentes, o que facilita a manutenção e a escalabilidade do código. Você pode criar manipuladores independentes e reutilizáveis sem se preocupar com a complexidade de controladores.

### 4. Suporte para Middlewares e Extensions

Apesar de sua simplicidade, o Carter ainda se integra bem com os middlewares do ASP.NET Core. Isso significa que você pode adicionar facilmente funcionalidades como autenticação, autorização e log de solicitações às suas APIs.

Outra forma é a utilização de Extensions como o FluentValidation que permite validar solicitações de entrada HTTP em minimal APIs do ASP.NET Core. 

### 5. Boa Performance

A simplicidade do Carter não compromete o desempenho. Ele oferece uma ótima performance em comparação com outras estruturas.

### 6. Testabilidade

A simplicidade do Carter torna mais fácil escrever testes unitários para seus manipuladores de rota, garantindo a qualidade do código.

## Como Começar com o Carter

Agora que você conhece algumas das vantagens do Carter, talvez esteja se perguntando como começar a usá-lo em seus projetos ASP.NET Core. Aqui estão algumas etapas simples para começar:

1. **Instalação**: Você pode adicionar o pacote Carter ao seu projeto usando o NuGet Package Manager. Execute o seguinte comando no console do NuGet:

   ```
   dotnet add package Carter
   ```

2. **Definindo Módulos**: Crie módulos Carter que herdam de `CarterModule` para definir suas rotas e manipuladores.

```csharp
using Carter;
using Carter.OpenApi;

namespace DemoCarter;

public class Module : CarterModule
{
    public Module()
    {
        WithTags("Module");
    }
    public override void AddRoutes(IEndpointRouteBuilder app)
    {
        app.MapGet("/", () =>
        {
            return "Hello Carter!";
        })
        .IncludeInOpenApi()
        .RequireAuthorization();
    }
}
```

3. **Configuração**: Adicione o Carter ao pipeline da aplicação.

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddCarter();
```

4. **Uso**: Use os módulos que você criou em sua aplicação.

```csharp
var app = builder.Build();

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

app.UseHttpsRedirection();

app.MapCarter();

app.Run();
  
```

Agora, você está pronto para começar a criar suas APIs RESTful com o Carter!

## Conclusão

O Carter é uma escolha sólida para o desenvolvimento de APIs em .NET quando você valoriza simplicidade, desempenho e um código limpo e de fácil manutenção. Ele oferece uma abordagem elegante para lidar com solicitações HTTP sem a complexidade dos controladores do ASP.NET Core MVC e a confusão das minimal APIs. Considere usar o Carter em seus projetos, avalie suas necessidades específicas e se suas vantagens se alinham com os objetivos do seu aplicativo. Com o Carter, você pode criar APIs eficientes e fáceis de manter em .NET.

Para saber mais: 
[Carter Github](https://github.com/CarterCommunity/Carter)