0Pricing
C# Academy · Aula

Fundamentos de DbContext e DbSet

Configure um DbContext, defina entidades, configure a cadeia de conexão e execute sua primeira consulta.

Fundamentos de DbContext e DbSet é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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.

O que é o Entity Framework Core

O EF Core é o mapeador objeto-relacional (ORM) oficial do .NET. Ele mapeia classes C# (entidades) para tabelas de banco de dados e permite consultar e salvar dados usando LINQ — sem SQL na maioria das operações.

Definindo uma entidade

Uma entidade é uma classe C# simples cujas propriedades correspondem a colunas do banco de dados. Por convenção, uma propriedade chamada Id ou <TypeName>Id se torna a chave primária.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime CreatedAt { get; set; }
}

Criando um DbContext

DbContext é a porta de entrada para o banco de dados. Ele contém propriedades DbSet<T> para cada entidade e gerencia a conexão, o rastreamento de alterações e as transações.

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    public DbSet<Product> Products => Set<Product>();
    public DbSet<Order>   Orders   => Set<Order>();
}

Registrando DbContext com DI

Chame AddDbContext em Program.cs para registrar o contexto como um serviço com escopo delimitado e configurar o provedor do banco de dados.

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("Default")));

// For SQLite (great for development/testing):
// options.UseSqlite("Data Source=app.db");

Consultas básicas com DbSet

DbSet<T> expõe operadores do LINQ. As consultas não são executadas até serem enumeradas (await ...ToListAsync()). Isso é chamado de execução adiada.

public class ProductService
{
    private readonly AppDbContext _db;
    public ProductService(AppDbContext db) => _db = db;

    public async Task<List<Product>> GetExpensiveAsync(decimal minPrice)
    {
        return await _db.Products
            .Where(p => p.Price >= minPrice)
            .OrderBy(p => p.Name)
            .ToListAsync();
    }
}

Encontrando pela chave primária

FindAsync verifica primeiro o cache local do rastreador de alterações antes de acessar o banco de dados. Use-o ao consultar pela chave primária para evitar idas e vindas redundantes ao banco.

var product = await _db.Products.FindAsync(42);
if (product is null)
    throw new KeyNotFoundException("Product not found");

// For complex keys, pass all key values:
var orderLine = await _db.OrderLines.FindAsync(orderId, productId);

Adicionando novos registros

Chame Add para colocar uma entidade na fila de inserção e, em seguida, SaveChangesAsync para confirmar. EF Core gera o SQL INSERT e preenche o Id gerado automaticamente.

var product = new Product
{
    Name = "Mechanical Keyboard",
    Price = 149.99m,
    Stock = 50,
    CreatedAt = DateTime.UtcNow
};

_db.Products.Add(product);
await _db.SaveChangesAsync();

Console.WriteLine(product.Id); // Auto-generated PK

Atualizando registros

As entidades carregadas pelo EF Core são rastreadas. Modifique as propriedades diretamente e chame SaveChangesAsync — EF Core detecta as alterações e gera uma instrução UPDATE otimizada.

var product = await _db.Products.FindAsync(42);
if (product is not null)
{
    product.Price = 129.99m;
    product.Stock -= 1;
    await _db.SaveChangesAsync(); // UPDATE Products SET Price=...
}

Excluindo registros

Chame Remove para marcar uma entidade para exclusão e, em seguida, SaveChangesAsync. Use ExecuteDeleteAsync (.NET 7+) para exclusões em massa sem carregar as entidades.

// Delete a tracked entity
_db.Products.Remove(product);
await _db.SaveChangesAsync();

// Bulk delete without loading (EF Core 7+)
await _db.Products
    .Where(p => p.Stock == 0)
    .ExecuteDeleteAsync();

Configurando com a Fluent API

Substitua OnModelCreating para configurar entidades usando a Fluent API — nomes de tabelas, tipos de colunas, restrições, índices e relacionamentos.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>(entity =>
    {
        entity.ToTable("products");
        entity.Property(p => p.Name).IsRequired().HasMaxLength(200);
        entity.Property(p => p.Price).HasColumnType("decimal(18,2)");
        entity.HasIndex(p => p.Name);
    });
}

Na prática: repositório usando DbContext

Um repositório típico encapsula DbContext para centralizar a lógica de acesso a dados e manter os detalhes das consultas fora das classes de serviço.

public class ProductRepository : IProductRepository
{
    private readonly AppDbContext _db;
    public ProductRepository(AppDbContext db) => _db = db;

    public async Task<Product?> GetByIdAsync(int id)
        => await _db.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);

    public async Task<List<Product>> SearchAsync(string query)
        => await _db.Products
            .Where(p => p.Name.Contains(query))
            .AsNoTracking()
            .ToListAsync();
}

Verificação rápida

O que AsNoTracking() faz ao realizar consultas com EF Core?

Revisão: fundamentos de DbContext e DbSet

Principais conclusões:

  • DbContext é a sessão com o banco de dados; DbSet<T> representa uma tabela
  • Registre-o com AddDbContext em DI; ele tem escopo delimitado por padrão
  • As consultas LINQ são adiadas — execute-as com ToListAsync ou FirstOrDefaultAsync
  • O rastreamento de alterações permite UPDATE/DELETE automáticos por meio de SaveChangesAsync
  • Use AsNoTracking() em consultas somente leitura para melhorar o desempenho

Perguntas Frequentes

A aula “Fundamentos de DbContext e DbSet” é grátis?

Sim — o texto completo de “Fundamentos de DbContext e DbSet” é 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 “Fundamentos de DbContext e DbSet”?

Configure um DbContext, defina entidades, configure a cadeia de conexão e execute sua primeira consulta. 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 1 de 4.

Quanto tempo leva a aula “Fundamentos de DbContext e DbSet”?

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

  1. Fundamentos de DbContext e DbSet
  2. Migrações e gerenciamento de esquema
  3. Operações CRUD com EF Core
  4. Relacionamentos: um para muitos e muitos para muitos
← Voltar para C# Academy