C# Academy · Aula

Operações CRUD com EF Core

Execute operações de criação, leitura, atualização e exclusão usando o controle de alterações do EF Core e SaveChanges.

Aula 3 de 413 etapas

Operações CRUD com EF Core é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Visão geral do CRUD no EF Core

EF Core trata das quatro operações CRUD — Criar, Ler, Atualizar, Excluir — por meio de uma combinação de rastreamento de alterações e SaveChangesAsync(). Entender o rastreador de alterações é a chave para dominar o CRUD.

Criar: adicionando uma nova entidade

Use DbSet.Add() ou AddAsync() para marcar uma entidade como Adicionada. Em SaveChangesAsync(), EF Core gera um INSERT e preenche a chave autoincremental.

var order = new Order
{
    CustomerId = 5,
    PlacedAt   = DateTime.UtcNow,
    Status     = OrderStatus.Pending
};

await _db.Orders.AddAsync(order);
await _db.SaveChangesAsync();

Console.WriteLine(order.Id); // populated by DB

Adicionando um grafo de entidades

Adicionar um pai com filhos em uma única chamada insere todo o grafo de objetos. EF Core resolve automaticamente os relacionamentos FK.

var order = new Order
{
    CustomerId = 5,
    PlacedAt   = DateTime.UtcNow,
    Lines      = new List<OrderLine>
    {
        new() { ProductId = 10, Quantity = 2, Price = 49.99m },
        new() { ProductId = 11, Quantity = 1, Price = 19.99m }
    }
};

_db.Orders.Add(order);
await _db.SaveChangesAsync();
// Inserts Order + 2 OrderLines in one transaction

Ler: consultando com LINQ

EF Core traduz expressões LINQ para SQL. Componha consultas usando Where, Select, OrderBy etc. e, em seguida, materialize-as com ToListAsync ou FirstOrDefaultAsync.

// Read all pending orders for a customer
var orders = await _db.Orders
    .Where(o => o.CustomerId == 5 && o.Status == OrderStatus.Pending)
    .OrderByDescending(o => o.PlacedAt)
    .Select(o => new OrderSummaryDto
    {
        Id     = o.Id,
        Total  = o.Lines.Sum(l => l.Quantity * l.Price),
        Status = o.Status.ToString()
    })
    .ToListAsync();

Ler: consultas de uma única entidade

Para leituras de uma única entidade, use FindAsync (verifica primeiro o rastreador) ou FirstOrDefaultAsync / SingleOrDefaultAsync com um predicado.

// By PK (checks cache first)
var order = await _db.Orders.FindAsync(orderId);

// By predicate (always hits DB)
var latest = await _db.Orders
    .Where(o => o.CustomerId == 5)
    .OrderByDescending(o => o.PlacedAt)
    .FirstOrDefaultAsync();

Atualizar: rastreamento de alterações

As entidades carregadas pelo EF Core são rastreadas. Modifique as propriedades diretamente e chame SaveChangesAsync(). EF Core detecta a diferença e gera uma instrução UPDATE mínima.

var order = await _db.Orders.FindAsync(orderId);
if (order is null) return;

order.Status   = OrderStatus.Shipped;
order.ShippedAt = DateTime.UtcNow;

await _db.SaveChangesAsync();
// UPDATE Orders SET Status=..., ShippedAt=... WHERE Id=orderId

Atualizar: atualização em massa (EF Core 7+)

ExecuteUpdateAsync atualiza as linhas diretamente no banco de dados sem carregar as entidades. É muito mais eficiente para operações em massa.

// Mark all overdue orders as Cancelled — no loading needed
await _db.Orders
    .Where(o => o.Status == OrderStatus.Pending
             && o.PlacedAt < DateTime.UtcNow.AddDays(-30))
    .ExecuteUpdateAsync(set => set
        .SetProperty(o => o.Status, OrderStatus.Cancelled)
        .SetProperty(o => o.UpdatedAt, DateTime.UtcNow));

Excluir: removendo uma única entidade

Chame Remove() em uma entidade rastreada e depois SaveChangesAsync(). Se você tiver apenas o ID, encontre a entidade primeiro ou use ExecuteDeleteAsync.

var order = await _db.Orders.FindAsync(orderId);
if (order is null) return;

_db.Orders.Remove(order);
await _db.SaveChangesAsync();
// DELETE FROM Orders WHERE Id=orderId

Excluir: exclusão em massa (EF Core 7+)

ExecuteDeleteAsync emite uma única instrução SQL DELETE sem carregar as entidades — ideal para operações de limpeza em lote.

// Delete all cancelled orders older than 1 year
int deleted = await _db.Orders
    .Where(o => o.Status == OrderStatus.Cancelled
             && o.PlacedAt < DateTime.UtcNow.AddYears(-1))
    .ExecuteDeleteAsync();

Console.WriteLine($"Deleted {deleted} old orders");

Transações

Todas as operações dentro de uma única chamada a SaveChangesAsync são encapsuladas em uma transação. Para operações com várias etapas e vários salvamentos, use uma transação explícita.

using var transaction = await _db.Database.BeginTransactionAsync();
try
{
    _db.Orders.Add(newOrder);
    await _db.SaveChangesAsync();

    inventory.Stock -= newOrder.Quantity;
    await _db.SaveChangesAsync();

    await transaction.CommitAsync();
}
catch
{
    await transaction.RollbackAsync();
    throw;
}

Na prática: serviço CRUD completo

Um serviço completo encapsula todas as operações CRUD com tratamento adequado de erros e retorna DTOs para evitar expor detalhes internos das entidades.

public async Task<OrderDto> CreateOrderAsync(CreateOrderRequest req)
{
    var order = new Order { CustomerId = req.CustomerId, PlacedAt = DateTime.UtcNow };
    _db.Orders.Add(order);
    await _db.SaveChangesAsync();
    return new OrderDto { Id = order.Id, Status = order.Status.ToString() };
}

public async Task<bool> CancelOrderAsync(int id)
{
    int rows = await _db.Orders
        .Where(o => o.Id == id && o.Status == OrderStatus.Pending)
        .ExecuteUpdateAsync(s =>
            s.SetProperty(o => o.Status, OrderStatus.Cancelled));
    return rows > 0;
}

Verificação rápida

Qual é a vantagem de ExecuteUpdateAsync / ExecuteDeleteAsync em relação a carregar entidades e chamar SaveChangesAsync?

Responda na aula interativa

Revisão: operações CRUD com EF Core

Principais conclusões:

Add + SaveChangesAsync → INSERT; EF Core preenche as chaves geradas automaticamente
Modifique entidades rastreadas + SaveChangesAsync → UPDATE mínimo
Remove + SaveChangesAsync → DELETE para entidades únicas
ExecuteUpdateAsync / ExecuteDeleteAsync → operações em massa sem carregamento (EF Core 7+)
Encapsule operações com várias etapas em uma transação explícita para garantir atomicidade

Grátis para começar

Aprenda C# com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 93
Aulas: 346

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Operações CRUD com EF Core” é grátis?

Sim — o texto completo de “Operações CRUD com EF Core” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Operações CRUD com EF Core”?

Execute operações de criação, leitura, atualização e exclusão usando o controle de alterações do EF Core e SaveChanges. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Operações CRUD com EF Core”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Fundamentos de DbContext e DbSet
Migrações e gerenciamento de esquema
Operações CRUD com EF Core
Relacionamentos: um para muitos e muitos para muitos

← Voltar para C# Academy