Entity Framework vs Dapper – Quando usar cada um no .NET?

Ao desenvolver uma aplicação no .NET, uma das escolhas mais importantes que você fará será sobre como interagir com o banco de dados. A decisão entre usar o Entity Framework (EF) ou o Dapper pode impactar diretamente o desempenho e a manutenibilidade do seu projeto. Ambos são ORMs (Object-Relational Mappers), ferramentas que permitem a interação com o banco de dados usando classes e objetos em vez de SQL manual.

Neste artigo, faremos uma comparação detalhada entre esses dois ORMs e mostraremos quando usar cada um, com exemplos passo a passo. Vamos explorar os ganhos e perdas ao usar o ORM certo ou errado para suas necessidades.

Pré-requisitos

Aqui está uma lista resumida dos pré-requisitos que você precisa configurar antes de implementar o Entity Framework e o Dapper no .NET:

NET 8 SDK: Baixe o .NET 8 SDK aqui. Após instalar, abra o Prompt de Comando (Windows) ou Terminal (Linux/macOS) e verifique a instalação com o comando:

dotnet --version

SQL Server: Baixe o SQL Server Developer Edition. Use o SQL Server Management Studio (SSMS) para gerenciar o banco de dados: Baixe o SSMS aqui.
Visual Studio: Download aqui.
VS Code: Download aqui.
Entity Framework Core
- Instale via NuGet

Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools

Dapper
- Instale via NuGet

Install-Package Dapper

String de Conexão do Banco de Dados
- Adicione ao arquivo appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=ORMComparisonDB;Trusted_Connection=True;"
  }
}

Postman (Ferramenta de Teste de API): Baixe aqui.

O que é um ORM?

Um ORM (Object-Relational Mapper) é uma ferramenta que facilita a interação com o banco de dados relacional ao permitir que você manipule dados diretamente com objetos e classes em C#, em vez de escrever consultas SQL manuais. Por exemplo, ao criar um objeto Produto em C#, o ORM converte automaticamente as operações realizadas nesse objeto em instruções SQL que interagem com o banco de dados.

ORMs geram SQL “por baixo dos panos”, o que torna o desenvolvimento mais rápido e o código mais limpo. Contudo, o uso de ORMs também pode impactar o desempenho, especialmente em aplicações de grande porte, onde a flexibilidade do SQL manual pode ser necessária.

Saiba mais sobre ORMs: Documentação Oficial sobre ORMs.

Quando usar o Entity Framework?

O Entity Framework (EF) é um ORM de alto nível desenvolvido pela Microsoft. Ele abstrai completamente as interações com o banco de dados, ou seja, ele esconde os detalhes técnicos de como o SQL é gerado e executado. Isso permite que o desenvolvedor trabalhe diretamente com objetos C#, como classes e métodos, sem a necessidade de escrever SQL manualmente. O EF é especialmente útil quando você quer focar na lógica de negócios e deixar que o ORM cuide das consultas ao banco.

Veja também: Guia Completo do Entity Framework.

Vantagens do Entity Framework

Abstração Total: O EF gera automaticamente as consultas SQL, permitindo que você se concentre na lógica de negócios da aplicação, sem se preocupar com os detalhes de como os dados são buscados ou inseridos no banco de dados. Isso torna a manutenção mais simples e reduz a chance de erros, já que você não precisa escrever SQL manualmente para cada operação.
LINQ (Language Integrated Query): Você pode escrever consultas diretamente em C# com LINQ, o que facilita a criação de consultas complexas e traz segurança de tipos.
Migrations: O EF permite gerenciar mudanças no banco de dados com migrations, sem a necessidade de scripts SQL manuais.

Leia mais sobre Migrations: Como usar Migrations no Entity Framework.

Implementando o Entity Framework no .NET 8 – Passo a Passo

Vamos implementar uma operação de CRUD (Criar, Ler, Atualizar, Deletar) usando o Entity Framework.

Passo 1: Configurando o Entity Framework

Abra o Visual Studio ou VS Code e crie um novo projeto ASP.NET Core Web API.

dotnet new webapi -n NomeDoProjeto

Instale os pacotes do Entity Framework executando os seguintes comandos no NuGet Package Manager:

Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools

Passo 2: Criando o DbContext e Modelos

No diretório Models, crie uma classe chamada Product.cs que representará a tabela no banco de dados:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

No arquivo appsettings.json, adicione a string de conexão do banco de dados:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=ORMComparisonDB;Trusted_Connection=True;"
  }
}

Agora, crie a classe ApplicationDbContext.cs que servirá como o contexto para o banco de dados:

public class ApplicationDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
}

Essa classe representa o banco de dados e o DbSet indica que você terá uma tabela chamada Products.

Passo 3: Adicionando o DbContext à Aplicação

No arquivo Program.cs (ou Startup.cs se você estiver usando uma versão anterior ao .NET 6), adicione o seguinte código para configurar o DbContext:

Add-Migration InitialCreate
Update-Database

Passo 4: Operações CRUD com Entity Framework

Vamos implementar um controlador para adicionar e buscar produtos. Crie um arquivo ProductsController.cs no diretório Controllers e adicione o seguinte código:

Adicionar Produto (POST):

[HttpPost]
public async Task<IActionResult> AddProduct(Product product)
{
    _context.Products.Add(product);
    await _context.SaveChangesAsync();
    return Ok(product);
}

Buscar Produto (GET):

[HttpGet("{id}")]
public async Task<IActionResult> GetProduct(int id)
{
    var product = await _context.Products.FindAsync(id);
    if (product == null)
    {
        return NotFound();
    }
    return Ok(product);
}

Agora, abra o Postman e crie uma nova requisição POST para adicionar um produto:

Defina a URL como https://localhost:5001/api/products.
Selecione o método POST.
No corpo da requisição, selecione raw e escolha JSON. Adicione o seguinte conteúdo:

{
  "name": "Notebook",
  "price": 2999.99
}

4. Clique em Send. Se tudo estiver configurado corretamente, você verá a resposta com o produto adicionado.

Ganhos ao Usar Entity Framework

Facilidade e Produtividade: Com o EF, você pode gerenciar alterações no banco de dados diretamente no código usando Migrations, sem escrever SQL. Isso é especialmente útil em projetos onde o banco de dados evolui constantemente.
Consultas Complexas Simplificadas: Consultas com relacionamentos complexos entre várias tabelas são facilmente resolvidas com o LINQ, reduzindo a complexidade do código e garantindo segurança de tipos.

Perda ao Usar Entity Framework em Cenários de Alta Performance

Se você usar o Entity Framework em cenários que exigem alto desempenho e controle sobre o SQL, pode ocorrer perda de eficiência. O overhead da abstração do EF, como o tracking de mudanças, pode tornar o sistema mais lento. Isso é mais evidente em grandes volumes de dados ou consultas frequentes e simples, onde o controle manual é crucial para otimizar a performance.

Quando usar o Dapper?

O Dapper é um micro ORM que oferece controle total sobre o SQL gerado e garante alta performance. Ele é ideal para cenários onde o desempenho é prioridade e onde você quer ter controle manual sobre o SQL.

Saiba mais: Dapper GitHub Repository.

Vantagens do Dapper

Desempenho Elevado: O Dapper é extremamente rápido, especialmente em operações de leitura e escrita.
Controle Total sobre o SQL: Diferente do Entity Framework, você escreve suas próprias consultas SQL, otimizando cada consulta.
Leveza: O Dapper não realiza tracking de entidades, o que reduz a sobrecarga de memória.

Quando Usar o Dapper?

Consultas simples: Se a aplicação realiza muitas consultas simples, o Dapper é a melhor escolha para performance.
Cenários de alta performance: Quando o controle sobre as consultas SQL e a velocidade de resposta são mais importantes que a abstração.

Implementando o Dapper no .NET 8 – Passo a Passo

Agora vamos ver como implementar o Dapper para realizar operações CRUD e entender os ganhos em relação ao Entity Framework.

Passo 1: Instalar e Configurar o Dapper

Instale o pacote Dapper via NuGet:

Install-Package Dapper

Crie a classe ProductRepository.cs para gerenciar operações de banco de dados:

using Dapper;
using System.Data.SqlClient;

public class ProductRepository
{
    private readonly string _connectionString;

    public ProductRepository(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection");
    }

    public async Task<IEnumerable<Product>> GetProducts()
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            return await connection.QueryAsync<Product>("SELECT * FROM Products");
        }
    }

    public async Task AddProduct(Product product)
    {
        var sql = "INSERT INTO Products (Name, Price) VALUES (@Name, @Price)";
        using (var connection = new SqlConnection(_connectionString))
        {
            await connection.ExecuteAsync(sql, new { product.Name, product.Price });
        }
    }
}

Passo 2: CRUD com Dapper

Adicionar Produto (POST):

public class ProductsDapperController : ControllerBase
{
    private readonly ProductRepository _repository;

    public ProductsDapperController(ProductRepository repository)
    {
        _repository = repository;
    }

    [HttpPost]
    public async Task<IActionResult> AddProduct(Product product)
    {
        await _repository.AddProduct(product);
        return Ok(product);
    }
}

Consulta de Produtos (GET):

[HttpGet]
public async Task<IActionResult> GetProducts()
{
    var products = await _repository.GetProducts();
    return Ok(products);
}

Ganhos ao Usar Dapper

Desempenho Elevado: O Dapper é significativamente mais rápido que o Entity Framework, especialmente em consultas simples e de leitura em massa. Em testes práticos, o Dapper foi até 3x mais rápido que o EF ao consultar 100.000 registros.
Controle Completo sobre o SQL: Você tem controle total sobre o SQL executado, o que permite otimizar consultas para cenários específicos e evitar o SQL gerado automaticamente pelo ORM.

Perda ao Usar Dapper em Cenários de Manutenção Complexa

Se você usar o Dapper em projetos grandes e complexos que exigem abstração e facilidade de manutenção, pode enfrentar dificuldades. Como o Dapper não oferece suporte a Migrations e não abstrai consultas complexas, isso pode aumentar significativamente o esforço de manutenção e causar inconsistências se o código SQL não for gerido corretamente. Além disso, em equipes grandes, o controle manual sobre as consultas SQL pode aumentar o risco de erros.

Comparação de Desempenho

Em um teste de desempenho comparando Entity Framework e Dapper, onde realizamos consultas em uma tabela com 100.000 registros:

Entity Framework: O tempo de execução para consultar todos os registros foi de 150ms. Esse tempo é impactado pelo tracking de entidades e a geração automática de SQL.
Dapper: A mesma consulta com Dapper levou 50ms, sendo cerca de 3x mais rápido que o EF. Isso ocorre porque o Dapper executa o SQL diretamente, sem a camada de abstração.

Quando Usar Entity Framework ou Dapper?

Use o Entity Framework Quando:

A Manutenibilidade é Prioridade: O EF é ideal quando você precisa gerenciar facilmente as mudanças no banco de dados e manter o código limpo.
Consultas Complexas: Se você precisa realizar consultas complexas que envolvem várias tabelas e relacionamentos, o EF facilita esse processo com LINQ.
Equipe Grande: Em equipes maiores, o EF permite que os desenvolvedores foquem na lógica do negócio sem precisar se preocupar com SQL.

Use o Dapper Quando:

Desempenho é Prioridade: Se você está lidando com grandes volumes de dados e consultas de leitura em massa, o Dapper é a melhor escolha pela sua leveza e velocidade.
Consultas Simples: Se você só precisa realizar operações simples de leitura e escrita no banco de dados, o Dapper oferece a melhor performance.
Controle Completo: Em cenários onde você quer otimizar cada consulta SQL ao máximo, o Dapper permite o controle total, sem as abstrações do Entity Framework.

Conclusão

Ao escolher entre Entity Framework e Dapper no .NET 8, é importante considerar o contexto da sua aplicação. O Entity Framework é ideal para quem busca abstração e facilidade de manutenção, especialmente em aplicações com consultas complexas. Já o Dapper se destaca em cenários onde a performance e o controle sobre o SQL são essenciais.

Com o ORM correto, você pode otimizar tanto a produtividade quanto o desempenho do seu projeto, garantindo que ele atenda às necessidades de longo prazo da sua equipe e dos seus usuários.

Veja também: Melhores práticas de otimização de desempenho com ORMs.