Criando um CRUD com Entity Framework

O que é o Entity Framework Core

O Entity Framework Core é um conjunto de bibliotecas para acesso a dados, criado e mantido pela Microsoft. Ele facilita a execução de operações CRUD no SQL Server e em outros bancos, como SQLite e PostgreSQL.

Segundo a documentação oficial do EF Core, ele é um mapeador objeto relacional, ou ORM. Em outras palavras, você trabalha com classes C# e o framework traduz tudo para SQL.

A grande diferença entre o Entity Framework e o Dapper é que o EF é um framework completo. Ou seja, ele abstrai muita coisa, inclusive a criação do banco e o código SQL.

O que é CRUD

CRUD é a sigla para CREATE (criar), READ (ler), UPDATE (atualizar) e DELETE (excluir). Em resumo, são as quatro operações básicas que fazemos nos bancos de dados.

O CRUD é conhecido como a base que todo programador precisa dominar. Inclusive, é quase certo que em alguma entrevista de emprego você terá que implementá-lo.

Por isso, entender como fazer um CRUD com EF Core vale tanto para projetos reais quanto para processos seletivos. Além disso, as mesmas ideias se repetem em APIs, aplicações web e serviços.

Ferramentas necessárias

Para seguir este tutorial, você precisa do .NET e do SQL Server instalados. Os artigos abaixo detalham a instalação dessas ferramentas:

• .NET: instalação, configuração e primeiros passos
• SQL Server no Docker

Se preferir algo ainda mais simples, você também pode usar o SQLite. Nesse caso, o banco vira um arquivo local e dispensa servidor.

Por fim, qualquer editor de código serve para acompanhar os exemplos, como o Visual Studio, o VS Code ou o Rider.

Criando o projeto do CRUD com EF Core

Vamos começar criando um projeto novo com o comando dotnet new, conforme mostrado abaixo. Neste caso, estou usando o .NET 7.

dotnet new console -o EfCrud
cd EfCrud

O comando cria um projeto do tipo console na pasta EfCrud. Em seguida, entramos na pasta para executar os próximos comandos.

Vale lembrar que o .NET 7 já saiu do período de suporte da Microsoft. Mesmo assim, os passos do CRUD com EF Core são praticamente os mesmos nas versões mais novas.

Iniciando com Code First

O Entity Framework tem uma abordagem de início diferente da que vimos no artigo sobre como criar um CRUD com Dapper. Essa abordagem se chama Code First.

Como o nome sugere, o Code First nos diz para codificar primeiro e esquecer o banco de dados por enquanto. No entanto, também podemos começar pelo banco, sem problemas; essa é a abordagem Database First.

De qualquer forma, vamos criar nossa classe, ou como carinhosamente chamamos, nossa entidade. Ela vai representar uma tabela no banco.

namespace EfCrud.Entities;

public class Category
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Slug { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
}

Se você preferir o caminho Database First, o dotnet-ef também resolve. O comando dotnet ef dbcontext scaffold lê um banco existente e gera as entidades e o contexto automaticamente.

Neste tutorial, porém, seguimos com o Code First, que é o caminho mais comum para quem está começando. Além disso, ele deixa o modelo do domínio sob controle do código, e não do banco.

Por convenção, o EF Core entende que a propriedade Id é a chave primária. Além disso, como ela é do tipo int, o SQL Server gera o valor automaticamente a cada inserção.

Ferramentas do Entity Framework

Para gerar o banco e executar outros comandos do EF, precisamos instalar uma ferramenta adicional. Essa ferramenta é o dotnet-ef, instalado como ferramenta global do .NET.

# Primeira instalação
dotnet tool install --global dotnet-ef

# Se você já tem a ferramenta e quer apenas
# atualizar para a última versão
dotnet tool update --global dotnet-ef

Com ele, você cria migrações, atualiza o banco e até gera classes a partir de um banco existente. Portanto, essa é uma peça importante do CRUD com EF Core.

Instalando o Entity Framework

Na raiz do projeto, instalamos o Entity Framework executando um dos comandos abaixo. A escolha depende do banco que você vai usar.

# Caso queira trabalhar com SQL Server
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

# Caso queira trabalhar com SQLite
dotnet add package Microsoft.EntityFrameworkCore.Sqlite

# Necessário para executar os comandos do dotnet-ef no projeto
dotnet add package Microsoft.EntityFrameworkCore.Design

A parte boa do Entity Framework é que ele abstrai o banco para nós. Assim, tanto faz se você quer usar SQLite ou SQL Server.

Como o projeto usa .NET 7, informe com --version uma versão 7.0.x de cada pacote. Isso é necessário porque as versões 8 em diante do EF Core exigem o .NET 8.

Além disso, a documentação recomenda usar a ferramenta e os pacotes com a mesma versão principal. Dessa forma, você evita erros estranhos ao rodar as migrações.

Data context

No CRUD com EF Core, o contexto de dados é basicamente a representação do banco de dados em memória. Fazemos as operações nele e, depois, ele transforma tudo em SQL e persiste as informações no banco.

using EfCrud.Entities;
using Microsoft.EntityFrameworkCore;

namespace EfCrud.Data;

public class AppDbContext : DbContext
{
    public DbSet<Category> Categories { get; set; } = null!;
}

using EfCrud.Entities;
using Microsoft.EntityFrameworkCore;

namespace EfCrud.Data;

public class AppDbContext : DbContext
{
    public DbSet<Category> Categories { get; set; } = null!;

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer("Server=localhost,1433;Database=EfCrud;User ID=sa;Password=1q2w3e4r@#$;Trusted_Connection=False;TrustServerCertificate=True;");
}

using EfCrud.Entities;
using Microsoft.EntityFrameworkCore;

namespace EfCrud.Data;

public class AppDbContext : DbContext
{
    public DbSet<Category> Categories { get; set; } = null!;

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlite("DataSource=app.db;Cache=Shared");
}

Gerando o banco do CRUD com EF Core

Com o contexto pronto, falta criar o banco e a tabela. Para isso, usamos as migrações do EF Core, que geram o esquema a partir das classes.

# Cria a migração inicial com base no AppDbContext
dotnet ef migrations add InitialCreate

# Cria o banco e aplica a migração
dotnet ef database update

O primeiro comando gera a pasta Migrations com o código que cria a tabela. Em seguida, o segundo comando executa esse código no banco configurado na connection string.

Sempre que você alterar uma entidade, crie uma nova migração e aplique no banco. O artigo sobre migrations com EF Core e PostgreSQL aprofunda esse fluxo.

Operações do CRUD com EF Core

Estamos na reta final. Agora, com tudo configurado, executamos as operações do CRUD com EF Core com muita facilidade.

Listei cada operação abaixo, da forma mais simples e objetiva possível. Lembre-se de adicionar using EfCrud.Data;, using EfCrud.Entities; e using Microsoft.EntityFrameworkCore; no Program.cs.

// Instância da entidade
var category = new Category
{
    Title = "Category 1",
    Slug = "category-1",
    Description = "Description of category 1"
};

// Instância do data context
using var context = new AppDbContext();

// Adiciona a entidade ao data context
await context.Categories.AddAsync(category);

// Persiste as mudanças
await context.SaveChangesAsync();

// Instância do data context
using var context = new AppDbContext();

// Lê todas as categorias
var categories = await context.Categories.ToListAsync();

// Busca a categoria com Id 1
var category = await context.Categories.FirstOrDefaultAsync(x => x.Id == 1);

// ERRADO: carrega a tabela inteira e só depois filtra em memória
var all = await context.Categories.ToListAsync();
var wrong = all.Where(x => x.Title.Contains("Category")).ToList();

// CORRETO: o filtro vira um WHERE no SQL
var right = await context.Categories
    .Where(x => x.Title.Contains("Category"))
    .ToListAsync();

// Instância do data context
using var context = new AppDbContext();

// Recupera a entidade (reidratação)
var category = await context.Categories.FirstOrDefaultAsync(x => x.Id == 1);

if (category is null)
    return;

// Altera a entidade
category.Title = "Updated category";

// Atualiza os dados no data context
context.Categories.Update(category);

// Persiste os dados no banco
await context.SaveChangesAsync();

// Instância do data context
using var context = new AppDbContext();

// Recupera a entidade
var category = await context.Categories.FirstOrDefaultAsync(x => x.Id == 1);

if (category is null)
    return;

// Remove a entidade do data context
context.Categories.Remove(category);

// Persiste as mudanças
await context.SaveChangesAsync();

// Atualiza o título direto no banco, sem carregar a entidade
await context.Categories
    .Where(x => x.Id == 1)
    .ExecuteUpdateAsync(s => s.SetProperty(x => x.Title, "Updated category"));

// Exclui direto no banco, sem carregar a entidade
await context.Categories
    .Where(x => x.Id == 1)
    .ExecuteDeleteAsync();

Executando o CRUD com EF Core no Program.cs

Para ver tudo funcionando, podemos juntar as quatro operações em um único Program.cs. Assim, você executa o CRUD com EF Core de ponta a ponta com um só comando.

using EfCrud.Data;
using EfCrud.Entities;
using Microsoft.EntityFrameworkCore;

using var context = new AppDbContext();

// Create: insere uma nova categoria
var category = new Category
{
    Title = "Category 1",
    Slug = "category-1",
    Description = "Description of category 1"
};
context.Categories.Add(category);
await context.SaveChangesAsync();
Console.WriteLine($"Created category {category.Id}");

// Read: lista todas as categorias sem rastreamento
var categories = await context.Categories.AsNoTracking().ToListAsync();
foreach (var item in categories)
    Console.WriteLine($"{item.Id}: {item.Title}");

// Update: altera o título da categoria criada
category.Title = "Updated category";
await context.SaveChangesAsync();

// Delete: remove a categoria criada
context.Categories.Remove(category);
await context.SaveChangesAsync();
Console.WriteLine("Category removed");

Depois de salvar, o EF Core preenche o Id gerado pelo banco na própria instância. Por isso, conseguimos exibir o valor logo após o SaveChangesAsync.

Repare que, no update, nem chamamos o Update. Como a entidade já está rastreada pelo contexto, o EF Core detecta a mudança e gera o UPDATE sozinho.

Para executar, basta rodar dotnet run na pasta do projeto. Em seguida, confira no banco que a tabela Categories recebeu e perdeu o registro.

Conclusão

Neste artigo, montamos um CRUD com EF Core do zero: criamos o projeto, a entidade, o data context e a migração. Em seguida, executamos as quatro operações básicas com poucas linhas de código.

O EF Core abstrai o SQL e o banco, o que acelera bastante o desenvolvimento. Ainda assim, entender o que acontece por baixo, como no caso do IQueryable, evita problemas de performance.

FAQ

O que significa CRUD?

CRUD significa Create, Read, Update e Delete, ou seja, criar, ler, atualizar e excluir. São as quatro operações básicas de qualquer banco de dados.

Preciso escrever SQL para usar o EF Core?

Não. O EF Core traduz as consultas LINQ e as operações do contexto para SQL automaticamente, embora também permita executar SQL quando necessário.

Por que preciso chamar o SaveChangesAsync?

Porque o contexto guarda as alterações em memória. O SaveChangesAsync é o método que gera os comandos SQL e grava as mudanças no banco.

Qual a diferença entre Code First e Database First?

No Code First, você cria as classes e gera o banco a partir delas. No Database First, você parte de um banco existente e gera as classes a partir dele.

Posso usar SQLite em vez de SQL Server?

Sim. Basta instalar o pacote Microsoft.EntityFrameworkCore.Sqlite e trocar o UseSqlServer por UseSqlite no contexto.