Padrão MVC com C# para APIs

O padrão MVC (Model-View-Controller) é uma arquitetura que separa as responsabilidades da aplicação em três componentes distintos: Model, View, e Controller. Em APIs, o foco geralmente está mais nos Models e Controllers, já que não há uma interface visual (View). A API serve dados no formato JSON, e a "View" se torna implícita no retorno dos dados.

Estrutura Básica

1. Model:

• Representa os dados e a lógica de negócio da aplicação. Em APIs, o modelo também define as entidades que serão usadas no banco de dados.

1. Controller:

• O controlador atua como intermediário entre a entrada do usuário (requisições HTTP) e a manipulação dos dados (Model). Ele processa as requisições, chama os modelos e retorna uma resposta no formato JSON.

1. View:

• Para APIs, o conceito de View é substituído pela resposta JSON, que representa os dados processados.

Exemplo de uma API simples com MVC em C#

No C#, o Model normalmente é uma classe que define a entidade usada pela API. Aqui temos um exemplo de um modelo Produto:

public class Produto
{
public int Id { get; set; }
public string Nome { get; set; }
public decimal Preco { get; set; }
}

Essa classe pode ser mapeada para uma tabela de banco de dados usando um ORM como o Entity Framework.

O Controller é responsável por lidar com as requisições HTTP, processar os dados do modelo e retornar uma resposta. Em APIs, ele lida com rotas e geralmente retorna dados no formato JSON.

Exemplo de um Controller:

[ApiController]
[Route("api/[controller]")]
public class ProdutoController : ControllerBase
{
private readonly DataContext _context;

public ProdutoController(DataContext context)
{
  _context = context;
}

// GET: api/produto
[HttpGet]
public IActionResult GetProdutos()
{
  var produtos = _context.Produtos.ToList(); // Obtém todos os produtos do banco
  return Ok(produtos); // Retorna uma lista de produtos em formato JSON
}

// GET: api/produto/5
[HttpGet("{id}")]
public IActionResult GetProduto(int id)
{
  var produto = _context.Produtos.Find(id);
  if (produto == null)
  {
    return NotFound(); // Retorna 404 se o produto não for encontrado
  }
  return Ok(produto); // Retorna o produto em formato JSON
}

// POST: api/produto
[HttpPost]
public IActionResult CreateProduto(Produto produto)
{
  _context.Produtos.Add(produto);
  _context.SaveChanges(); // Persiste no banco de dados
  return CreatedAtAction(nameof(GetProduto), new { id = produto.Id }, produto); // Retorna 201 com o novo produto
}
}

View (Resposta JSON)

No caso de APIs, o retorno dos dados é feito em formato JSON, e o Controller usa métodos como Ok(), NotFound(), e CreatedAtAction() para estruturar a resposta.

Exemplo de resposta JSON para a rota GET /api/produto/5:

{
"id": 5,
"nome": "Produto Exemplo",
"preco": 49.99
}

Resumo do Fluxo MVC em API

1. Requisição: O cliente faz uma requisição HTTP para a API, como GET /api/produto.
2. Controller: O controlador processa a requisição, interage com o modelo (banco de dados) e retorna a resposta.
3. Model: O modelo lida com a lógica dos dados e o armazenamento. Os dados são recuperados, atualizados ou excluídos conforme a ação do controlador.
4. Resposta: A resposta é enviada no formato JSON (a "View" implícita).

Vantagens do MVC em APIs

1. Separação de responsabilidades: O padrão MVC divide claramente o código em responsabilidades distintas (dados, controle e apresentação), facilitando a manutenção e escalabilidade.
2. Reutilização: Controladores podem ser reutilizados para lidar com diferentes tipos de requisições (GET, POST, PUT, DELETE), mantendo a lógica central em um lugar.
3. Organização: Mantém a estrutura da aplicação modular e organizada.