Usando Entity Framework em APIs

18/06/2024

O Entity Framework (EF) é um Object-Relational Mapper (ORM) para .NET, desenvolvido pela Microsoft, que simplifica a interação com bancos de dados relacionais. Quando combinado com APIs, especialmente em arquiteturas de microserviços e RESTful APIs, o EF oferece uma maneira robusta e eficiente de realizar operações CRUD (Create, Read, Update, Delete). Neste artigo, exploraremos como usar o Entity Framework em APIs para criar aplicações modernas, escaláveis e de fácil manutenção.

Benefícios do Entity Framework em APIs

Abstração do Banco de Dados: Permite trabalhar com dados como objetos, eliminando a necessidade de SQL explícito.
Consultas LINQ: Facilita a escrita de consultas de forma expressiva e fortemente tipada.
Migrations: Gerencia mudanças no esquema do banco de dados de maneira segura e automática.
Integração Simples: Fácil de integrar com ASP.NET Core para construir APIs RESTful.

Configuração Inicial

1. Criação do Projeto

Primeiro, crie um novo projeto ASP.NET Core Web API:

dotnet new webapi -n MyApi cd MyApi

2. Instalação dos Pacotes Necessários

Instale os pacotes do Entity Framework Core:

dotnet add package Microsoft.EntityFrameworkCore

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

dotnet add package Microsoft.EntityFrameworkCore.Tools

Configuração do Entity Framework

1. Definição do Modelo

Crie as classes de modelo que representarão as tabelas no banco de dados:

public class Blog  
{  
    public int BlogId { get; set; }  
    public string Name { get; set; }  
    public ICollection<Post> Posts { get; set; }  
}  
  
public class Post  
{  
    public int PostId { get; set; }  
    public string Title { get; set; }  
    public string Content { get; set; }  
    public int BlogId { get; set; }  
    public Blog Blog { get; set; }  
}  

2. Criação do DbContext

Crie a classe de contexto que gerencia as entidades:

public class BloggingContext : DbContext  
{  
    public BloggingContext(DbContextOptions<BloggingContext> options)  
        : base(options)  
    {  
    }  
  
    public DbSet<Blog> Blogs { get; set; }  
    public DbSet<Post> Posts { get; set; }  
}  

3. Configuração do DbContext no Startup

Configure o DbContext no arquivo Startup.cs:

public void ConfigureServices(IServiceCollection services)  
{  
    services.AddDbContext<BloggingContext>(options =>  
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));  
  
    services.AddControllers();  
}  

Adicione a string de conexão no appsettings.json:

{  
  "ConnectionStrings": {  
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=BloggingDb;Trusted_Connection=True;MultipleActiveResultSets=true"  
  }  
}  

Criação de Controladores

1. Controlador de Blogs

Crie um controlador para gerenciar blogs:

[Route("api/[controller]")]  
[ApiController]  
public class BlogsController : ControllerBase  
{  
    private readonly BloggingContext _context;  
  
    public BlogsController(BloggingContext context)  
    {  
        _context = context;  
    }  
  
    [HttpGet]  
    public async Task<ActionResult<IEnumerable<Blog>>> GetBlogs()  
    {  
        return await _context.Blogs.Include(b => b.Posts).ToListAsync();  
    }  
  
    [HttpGet("{id}")]  
    public async Task<ActionResult<Blog>> GetBlog(int id)  
    {  
        var blog = await _context.Blogs.Include(b => b.Posts)  
                                       .FirstOrDefaultAsync(b => b.BlogId == id);  
  
        if (blog == null)  
        {  
            return NotFound();  
        }  
  
        return blog;  
    }  
  
    [HttpPost]  
    public async Task<ActionResult<Blog>> PostBlog(Blog blog)  
    {  
        _context.Blogs.Add(blog);  
        await _context.SaveChangesAsync();  
  
        return CreatedAtAction("GetBlog", new { id = blog.BlogId }, blog);  
    }  
  
    [HttpPut("{id}")]  
    public async Task<IActionResult> PutBlog(int id, Blog blog)  
    {  
        if (id != blog.BlogId)  
        {  
            return BadRequest();  
        }  
  
        _context.Entry(blog).State = EntityState.Modified;  
  
        try  
        {  
            await _context.SaveChangesAsync();  
        }  
        catch (DbUpdateConcurrencyException)  
        {  
            if (!BlogExists(id))  
            {  
                return NotFound();  
            }  
            else  
            {  
                throw;  
            }  
        }  
  
        return NoContent();  
    }  
  
    [HttpDelete("{id}")]  
    public async Task<IActionResult> DeleteBlog(int id)  
    {  
        var blog = await _context.Blogs.FindAsync(id);  
        if (blog == null)  
        {  
            return NotFound();  
        }  
  
        _context.Blogs.Remove(blog);  
        await _context.SaveChangesAsync();  
  
        return NoContent();  
    }  
  
    private bool BlogExists(int id)  
    {  
        return _context.Blogs.Any(e => e.BlogId == id);  
    }  
}  

Executando Migrations

Para criar e aplicar as migrations:

dotnet ef migrations add InitialCreate
dotnet ef database update

Testando a API

Execute a aplicação e use uma ferramenta como Postman ou o Swagger UI integrado para testar os endpoints da API.

Integrar o Entity Framework em APIs ASP.NET Core proporciona uma maneira eficiente e escalável de gerenciar operações de banco de dados. O EF simplifica a interação com os dados, permitindo que os desenvolvedores se concentrem na lógica de negócios. Com as habilidades apresentadas neste artigo, você pode começar a desenvolver APIs robustas que aproveitam o poder do Entity Framework.

Autor: José Darci Rodrigues Junior