Introdução às Minimal APIs no .NET 8: Simplificando o Desenvolvimento RESTful
Tags: tutorial, dotnet, braziliandevs, beginners
Published: 2024-02-29 18:53:00

### Introdução

Se você está no mundo do desenvolvimento web, provavelmente já ouviu falar sobre Minimal APIs. Elas são a resposta do .NET para criar APIs web sem toda aquela complexidade e verbosidade típicas. Basicamente, elas permitem que você defina endpoints HTTP super rápido e com pouquíssimo código. Isso é música para os ouvidos de quem adora eficiência.

Com a chegada do .NET 8, as coisas ficaram ainda mais interessantes para as Minimal APIs. Temos um monte de melhorias e novidades que vão desde deixar o código mais limpinho até facilitar a vida com documentação automática e diagnósticos aprimorados. É como pegar algo que já era bom e turbinar com novos poderes.

E por que você deveria se importar? Simples: porque isso significa escrever menos código, cometer menos erros e, de quebra, fazer tudo isso de um jeito mais rápido. As novidades nas Minimal APIs estão aqui para fazer seu trabalho como desenvolvedor mais ágil e seus projetos mais robustos e fáceis de manter.

Neste tutorial, vamos mergulhar nessas novidades e mostrar como elas podem fazer a diferença no seu dia a dia de desenvolvimento de APIs com ASP.NET Core. Preparado? Então, vamos lá!

Perfeito, vamos à seção de configuração do ambiente, mantendo o tom casual e direto:

---

### Configuração do Ambiente

Antes de mergulharmos nas maravilhas das Minimal APIs com .NET 8, precisamos preparar o terreno. Vou te guiar por um caminho sem espinhos para configurar tudo o que é necessário. Vamos lá?

#### Instalando o .NET 8 SDK

Primeiro de tudo, precisamos ter certeza de que o .NET 8 SDK está instalado na sua máquina. Isso vai permitir que a gente crie e rode nossas aplicações .NET sem percalços.

1. **Visite a página oficial do .NET** (você pode simplesmente procurar por “.NET 8 SDK download” no seu buscador favorito).
2. **Escolha o SDK** adequado para o seu sistema operacional (Windows, Linux ou macOS) e faça o download.
3. **Siga as instruções de instalação** específicas para o seu sistema. Normalmente, é só um next-next-finish, mas é sempre bom prestar atenção.

#### Configurando seu Ambiente de Desenvolvimento

Com o SDK pronto, é hora de escolher onde você vai escrever seu código. Se você já tem uma IDE de preferência, ótimo! Caso contrário, aqui vão duas sugestões top de linha:

- **Visual Studio 2022** ou superior: Perfeito para desenvolvedores .NET, cheio de recursos e facilitadores. Além disso, tem uma integração excelente com o .NET 8.
- **Visual Studio Code**: Leve, versátil e gratuito. Com os plugins certos, se torna uma ferramenta poderosa para desenvolvimento .NET.

#### Criando um Novo Projeto de API

Hora de colocar a mão na massa. Vamos criar nosso primeiro projeto de API com .NET 8. Você pode fazer isso pelo terminal ou diretamente pela sua IDE favorita. Aqui, vou te mostrar como fazer pelo terminal, que é universal:

1. **Abra o terminal** (ou Prompt de Comando, PowerShell, Terminal do Linux, etc.).
2. **Navegue até a pasta** onde você quer criar seu projeto.
3. **Digite o comando** abaixo e pressione Enter:

```bash
dotnet new webapi -n MinhaPrimeiraAPI
```

Esse comando vai criar um novo projeto de API chamado "MinhaPrimeiraAPI" com tudo o que você precisa para começar. Bem simples, né?

4. **Entre na pasta do projeto** com `cd MinhaPrimeiraAPI` e digite `dotnet run` para iniciar sua API. Se tudo deu certo, você verá uma mensagem indicando que a aplicação está rodando e esperando por requisições.

E aí está, seu ambiente está configuradíssimo! Agora, estamos prontos para explorar as novidades e melhorias das Minimal APIs no .NET 8.

---

### Primeiros Passos com Minimal APIs

Agora que você tem seu ambiente todo configurado, vamos dar uma olhada em como começar com as Minimal APIs. Elas são todas sobre simplificar ao máximo o desenvolvimento de APIs, então prepare-se para se surpreender com a facilidade.

#### Entendendo a Estrutura do Projeto

Quando você cria um novo projeto de API no .NET 8, a estrutura é minimalista por natureza. Basicamente, você tem:

- **Program.cs**: O coração do seu projeto. É aqui que você vai definir seus endpoints e configurar serviços. Tudo em um arquivo só, sem complicações.
- **appsettings.json**: Aqui ficam as configurações do projeto, como strings de conexão, configurações de logging, etc.
- **wwwroot**: Pasta para arquivos estáticos, caso sua API sirva algum conteúdo desse tipo.

E isso é praticamente tudo! Claro, conforme seu projeto cresce, você pode adicionar mais arquivos e pastas, mas o início é super enxuto.

#### Criando um Endpoint "Hello World"

Vamos criar o endpoint mais clássico do mundo da programação: o bom e velho "Hello World". Veja como é fácil:

1. **Abra o arquivo Program.cs**. Você vai ver que ele já vem com algum código básico.

2. **Adicione um endpoint**. Localize o método `app.MapGet()` e vamos modificá-lo para retornar "Hello World". Seu código deve ficar assim:

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

app.MapGet("/", () => "Hello World!");

app.Run();
```

3. **Rode sua aplicação**. Volte ao terminal, certifique-se de que você está na pasta do seu projeto, e execute `dotnet run`.

4. **Teste o endpoint**. Abra seu navegador e vá para `http://localhost:5000/` (ou a porta que foi configurada). Você deverá ver "Hello World!" na tela.

#### A Simplicidade em Ação

Comparando com as versões anteriores do .NET, a quantidade de código necessário para levantar uma API com um endpoint funcional é notavelmente menor. Antes, precisávamos lidar com a configuração do Startup.cs, definir Controllers, e mais um monte de passos que, para projetos simples, eram um tanto quanto exagerados.

As Minimal APIs vieram para dizer: "Ei, vamos focar no que realmente importa e cortar o excesso". E isso, amigos, é uma bela de uma evolução.

### Explorando as Novidades e Melhorias

O .NET 8 trouxe várias atualizações significativas para as Minimal APIs, tornando-as ainda mais poderosas e fáceis de usar. Vamos explorar algumas dessas novidades:

#### Melhorias na Sintaxe para Definição de Endpoints

No .NET 8, a sintaxe para definir endpoints foi aprimorada para ser ainda mais intuitiva e flexível. Isso significa menos boilerplate e mais clareza.

**Antes:**

```csharp
app.MapGet("/", () => "Hello World!");
```

**Agora:**

Você pode agrupar endpoints relacionados de forma mais elegante, facilitando a organização e a leitura do código.

```csharp
app.MapGroup("/api")
   .MapGet("/hello", () => "Hello World!")
   .MapPost("/hello", () => Results.Ok("Hello World posted!"));
```

**Benefício:** Esta nova maneira permite uma melhor organização do código, especialmente em APIs maiores, onde a clareza na definição de rotas é essencial.

#### Novas Funcionalidades para Tratamento de Erros e Validação de Entrada

O .NET 8 introduziu maneiras mais robustas e simples de tratar erros e validar entradas, reduzindo a necessidade de código repetitivo.

**Exemplo de Validação de Entrada:**

```csharp
app.MapPost("/submit", (string name) => 
{
    if (string.IsNullOrEmpty(name))
    {
        return Results.BadRequest("Name is required.");
    }
    return Results.Ok($"Hello {name}!");
});
```

**Benefício:** Simplifica a validação de entradas, tornando o código mais limpo e fácil de manter.

#### Aprimoramentos em Logging e Diagnóstico

Melhorias significativas foram feitas na área de logging e diagnósticos, facilitando a identificação e resolução de problemas em suas APIs.

**Exemplo:**

Você pode agora configurar o logging diretamente no `Program.cs` de forma mais intuitiva, aproveitando os novos aprimoramentos.

```csharp
builder.Logging.AddConsole();
```

**Benefício:** Oferece uma visão mais clara do que está acontecendo com sua aplicação, tornando o diagnóstico de problemas mais eficiente.

#### Integração com OpenAPI/Swagger para Documentação Automática

A integração com OpenAPI/Swagger foi simplificada, facilitando a geração de documentação para suas APIs.

**Exemplo:**

Para habilitar a documentação automática com Swagger, basta adicionar uma linha ao seu `Program.cs`:

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

E para visualizar a documentação, adicione:

```csharp
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
```

**Benefício:** Isso torna incrivelmente fácil gerar e servir documentação atualizada para sua API, melhorando a experiência de desenvolvimento e facilitando a integração para usuários finais.

---

Agora que já exploramos as novidades e melhorias das Minimal APIs no .NET 8, vamos colocar a mão na massa e construir uma API CRUD simples. Esse exemplo vai te mostrar como criar uma aplicação RESTful completa, desde a definição de modelos de dados até a implementação das operações CRUD, aproveitando as facilidades do .NET 8.

### Construindo uma API CRUD com .NET 8

#### 1. Preparando o Projeto

Assumindo que você já tem o ambiente configurado conforme instruído anteriormente, o primeiro passo é criar um novo projeto de API se ainda não tiver um.

```bash
dotnet new webapi -n ApiCrudExemplo --no-https
cd ApiCrudExemplo
```

#### 2. Adicionando o Entity Framework Core

Vamos adicionar o Entity Framework Core ao projeto, que será nosso ORM para interagir com o banco de dados.

```bash
dotnet add package Microsoft.EntityFrameworkCore.InMemory
```

Estamos usando um banco de dados em memória para simplificar, mas você pode adaptar para qualquer banco de dados suportado pelo EF Core.

#### 3. Definindo o Modelo de Dados

Crie um novo arquivo `TodoItem.cs` para definir o modelo de dados:

```csharp
public class TodoItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
}
```

#### 4. Criando o Contexto do EF Core

Adicione um novo arquivo `TodoDbContext.cs` para criar o contexto do EF Core:

```csharp
using Microsoft.EntityFrameworkCore;

public class TodoDbContext : DbContext
{
    public TodoDbContext(DbContextOptions<TodoDbContext> options)
        : base(options) { }

    public DbSet<TodoItem> TodoItems { get; set; }
}
```

No seu `Program.cs`, adicione o contexto como um serviço:

```csharp
builder.Services.AddDbContext<TodoDbContext>(opt => opt.UseInMemoryDatabase("TodoList"));
```

#### 5. Implementando as Operações CRUD

Agora, vamos adicionar os endpoints para as operações CRUD no `Program.cs`.

**Create:**

```csharp
app.MapPost("/todo", async (TodoItem todoItem, TodoDbContext context) =>
{
    context.TodoItems.Add(todoItem);
    await context.SaveChangesAsync();
    return Results.Created($"/todo/{todoItem.Id}", todoItem);
});
```

**Read (All items and Single item):**

```csharp
app.MapGet("/todo", async (TodoDbContext context) => await context.TodoItems.ToListAsync());

app.MapGet("/todo/{id}", async (int id, TodoDbContext context) =>
{
    return await context.TodoItems.FindAsync(id)
           ?? Results.NotFound();
});
```

**Update:**

```csharp
app.MapPut("/todo/{id}", async (int id, TodoItem inputTodoItem, TodoDbContext context) =>
{
    var todoItem = await context.TodoItems.FindAsync(id);

    if (todoItem == null) return Results.NotFound();

    todoItem.Name = inputTodoItem.Name;
    todoItem.IsComplete = inputTodoItem.IsComplete;

    await context.SaveChangesAsync();

    return Results.NoContent();
});
```

**Delete:**

```csharp
app.MapDelete("/todo/{id}", async (int id, TodoDbContext context) =>
{
    var todoItem = await context.TodoItems.FindAsync(id);

    if (todoItem == null) return Results.NotFound();

    context.TodoItems.Remove(todoItem);
    await context.SaveChangesAsync();

    return Results.NoContent();
});
```

#### 6. Testando a API

Agora que nossa API CRUD está pronta, você pode testá-la usando ferramentas como Postman ou Swagger. Lembre-se de adicionar o Swagger ao seu projeto para facilitar os testes:

```csharp
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
```

Execute o projeto com `dotnet run` e acesse a documentação do Swagger em `http://localhost:5000/swagger` para ver e testar seus endpoints.

---

### Boas Práticas e Dicas

#### Organização do Código
- **Modularize seu código**: Mesmo que as Minimal APIs favoreçam arquivos únicos, para aplicações maiores, considere separar lógicas em arquivos ou classes distintas.
- **Agrupe endpoints relacionados**: Use `app.MapGroup()` para organizar endpoints logicamente, facilitando a manutenção e melhorando a legibilidade.

#### Segurança
- **Autenticação e Autorização**: Não negligencie a segurança. Implemente autenticação JWT ou outra estratégia adequada para proteger suas APIs.
- **Validação de Entradas**: Sempre valide as entradas para evitar injeções SQL e outros ataques comuns.

#### Performance
- **Asynchronous Processing**: Use operações assíncronas (`async/await`) para melhorar a performance de suas APIs.
- **Monitoramento**: Utilize ferramentas de monitoramento e logging para identificar e solucionar gargalos de performance.

#### Testando e Depurando
- **Use o Swagger**: Facilita o teste de endpoints diretamente no navegador.
- **Logging**: Configure o logging adequado para ajudar na depuração de problemas.

#### Recursos Recomendados
- **Documentação Oficial do .NET**: Sempre atualizada e cheia de exemplos.
- **Microsoft Learn**: Cursos e tutoriais gratuitos sobre .NET e Minimal APIs.
- **GitHub**: Procure por projetos de exemplo e contribua com a comunidade.

---

Neste artigo, exploramos o mundo das Minimal APIs no .NET 8, desde a configuração do ambiente até a construção de uma API CRUD completa. As melhorias e novidades introduzidas no .NET 8 simplificam ainda mais o desenvolvimento de APIs RESTful, permitindo que nos concentremos no que realmente importa.

Encorajo você a experimentar as Minimal APIs em seus projetos. Elas podem transformar sua maneira de desenvolver APIs, tornando o processo mais rápido, mais intuitivo e, definitivamente, mais divertido.

Muito obrigado por acompanhar este tutorial até o fim. Espero que tenha encontrado informações úteis e inspiração para seus próximos projetos. Se tiver dúvidas, sugestões ou quiser compartilhar suas experiências, não hesite em entrar em contato ou deixar um comentário.

E lembrando que botar a mão na massa é essencial, então, comece um novo projeto e veja por si mesmo como as Minimal APIs podem ser poderosas. Compartilhe seus resultados e descobertas usando a hashtag #MinimalAPIsDotNet8. Vamos aprender e crescer juntos nesta jornada de desenvolvimento.