1. Configurando o Projeto e Instalando Dependências
Para começar, vamos criar um novo projeto ASP.NET Core e instalar os pacotes necessários para conectar o projeto ao MySQL utilizando o Entity Framework Core.
// Criando um novo projeto de API com ASP.NET Core
dotnet new webapi -n MinhaApiMySQL
// Instalando os pacotes do MySQL e Entity Framework Core
dotnet add package Pomelo.EntityFrameworkCore.MySql
dotnet add package Microsoft.EntityFrameworkCore.Tools
A biblioteca Pomelo.EntityFrameworkCore.MySql é amplamente utilizada para conectar aplicações ASP.NET Core ao MySQL. O pacote Microsoft.EntityFrameworkCore.Tools é necessário para gerar migrations e manipular o banco de dados via Entity Framework Core.
2. Configurando a Conexão ao MySQL
Após instalar os pacotes, precisamos configurar a conexão ao banco de dados MySQL no arquivo appsettings.json. A string de conexão deve incluir o nome do servidor MySQL, o banco de dados e as credenciais de login.
// Exemplo de string de conexão com MySQL em appsettings.json
{
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=MinhaApiDb;User=root;Password=senha;"
}
}
Agora, vamos configurar o DbContext para usar o MySQL. No arquivo Startup.cs ou Program.cs, adicione o seguinte código para registrar o contexto do banco de dados:
// Exemplo de configuração de DbContext com MySQL
using Microsoft.EntityFrameworkCore;
public class AppDbContext : DbContext {
public DbSet<Produto> Produtos { get; set; }
public AppDbContext(DbContextOptions<AppDbContext> options)
: base(options) {
}
}
// Registrando o DbContext no Startup.cs (ou Program.cs)
public void ConfigureServices(IServiceCollection services) {
services.AddDbContext<AppDbContext>(options =>
options.UseMySql(Configuration.GetConnectionString("DefaultConnection"),
ServerVersion.AutoDetect(Configuration.GetConnectionString("DefaultConnection"))));
}
No exemplo acima, estamos configurando o Entity Framework Core para usar o MySQL com base na string de conexão definida no arquivo appsettings.json. O método ServerVersion.AutoDetect é utilizado para detectar automaticamente a versão do MySQL, simplificando a configuração.
3. Criando o Modelo de Dados
Agora, vamos criar o modelo de dados que representará a tabela Produtos no banco de dados. O modelo será uma classe C# simples:
// Exemplo de modelo Produto
public class Produto {
public int Id { get; set; }
public string Nome { get; set; }
public decimal Preco { get; set; }
}
O Entity Framework Core usará essa classe para mapear os dados entre a aplicação e a tabela no banco MySQL.
4. Gerando Migrations e Criando o Banco de Dados
Para criar o banco de dados e as tabelas, usamos o recurso de migrations do Entity Framework Core. Primeiro, geramos uma migration para criar as tabelas, e em seguida, aplicamos as mudanças no banco de dados.
// Gerando a migration inicial
dotnet ef migrations add InitialCreate
// Aplicando a migration para criar o banco de dados
dotnet ef database update
Após aplicar o comando dotnet ef database update, o Entity Framework criará automaticamente o banco de dados e a tabela Produtos no MySQL, com base no modelo de dados definido.
5. Criando o Controlador para a API
Com o banco de dados configurado, vamos criar um controlador que permita realizar operações CRUD na tabela Produtos através da API. O controlador usará o AppDbContext para acessar o banco de dados.
// Exemplo de controlador de API para Produtos
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
[ApiController]
[Route("api/[controller]")]
public class ProdutosController : ControllerBase {
private readonly AppDbContext _context;
public ProdutosController(AppDbContext context) {
_context = context;
}
[HttpGet]
public async Task<ActionResult<IEnumerable<Produto>>> GetProdutos() {
return await _context.Produtos.ToListAsync();
}
[HttpGet("{id}")]
public async Task<ActionResult<Produto>> GetProduto(int id) {
var produto = await _context.Produtos.FindAsync(id);
if (produto == null) {
return NotFound();
}
return produto;
}
[HttpPost]
public async Task<ActionResult<Produto>> PostProduto(Produto produto) {
_context.Produtos.Add(produto);
await _context.SaveChangesAsync();
return CreatedAtAction(nameof(GetProduto), new { id = produto.Id }, produto);
}
[HttpPut("{id}")]
public async Task<IActionResult> PutProduto(int id, Produto produto) {
if (id != produto.Id) {
return BadRequest();
}
_context.Entry(produto).State = EntityState.Modified;
await _context.SaveChangesAsync();
return NoContent();
}
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteProduto(int id) {
var produto = await _context.Produtos.FindAsync(id);
if (produto == null) {
return NotFound();
}
_context.Produtos.Remove(produto);
await _context.SaveChangesAsync();
return NoContent();
}
}
O controlador ProdutosController contém ações para listar, adicionar, atualizar e remover produtos da tabela no banco MySQL, utilizando o Entity Framework para manipular os dados.
Conclusão
Integrar uma API ASP.NET Core com um banco de dados MySQL usando o Entity Framework Core é uma abordagem eficiente para criar APIs modernas e robustas. A combinação do Entity Framework com o MySQL permite que você mapeie modelos de dados, execute operações CRUD e mantenha um código limpo e organizado. Seguindo os passos descritos neste artigo, você poderá configurar sua própria API com MySQL de maneira rápida e eficiente.