C# Academy · Lección

Fundamentos de DbContext y DbSet

Configure un DbContext, defina entidades, configure la cadena de conexión y ejecute su primera consulta.

Fundamentos de DbContext y DbSet es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es Entity Framework Core?

EF Core es el Object-Relational Mapper (ORM) oficial de .NET. Asigna clases de C# —entidades— a tablas de la base de datos y permite consultar y guardar datos mediante LINQ; para la mayoría de las operaciones no se necesita SQL.

Definir una entidad

Una entidad es una clase de C# sencilla cuyas propiedades se asignan a columnas de la base de datos. Por convención, una propiedad llamada Id o <TypeName>Id se convierte en la clave principal.

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; }
}

Crear un DbContext

DbContext es la puerta de entrada a la base de datos. Contiene propiedades DbSet<T> para cada entidad y administra la conexión, el seguimiento de cambios y las transacciones.

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>();
}

Registrar DbContext con DI

Llame a AddDbContext en Program.cs para registrar el contexto como un servicio con ámbito Scoped y configurar el proveedor de base de datos.

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 con DbSet

DbSet<T> expone operadores LINQ. Las consultas no se ejecutan hasta que se enumeran (await ...ToListAsync()). Esto se denomina ejecución diferida.

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();
    }
}

Buscar por clave principal

FindAsync comprueba primero la caché local del seguimiento de cambios antes de acceder a la base de datos. Úselo al consultar por clave principal para evitar viajes de ida y vuelta redundantes.

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);

Agregar registros nuevos

Llame a Add para poner una entidad en cola para su inserción y, después, a SaveChangesAsync para confirmar los cambios. EF Core genera el SQL INSERT y rellena el Id autogenerado.

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

Actualizar registros

EF Core realiza el seguimiento de las entidades cargadas. Modifique las propiedades directamente y llame a SaveChangesAsync: EF Core detecta los cambios y genera una instrucción UPDATE optimizada.

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=...
}

Eliminar registros

Llame a Remove para marcar una entidad para su eliminación y, después, a SaveChangesAsync. Use ExecuteDeleteAsync (.NET 7+) para eliminar registros en bloque sin cargar las 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();

Configurar con la API Fluent

Invalide OnModelCreating para configurar las entidades mediante la API Fluent: nombres de tablas, tipos de columnas, restricciones, índices y relaciones.

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);
    });
}

En la práctica: repositorio que usa DbContext

Un repositorio típico encapsula DbContext para centralizar la lógica de acceso a datos y mantener los detalles de las consultas fuera de las clases de servicio.

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();
}

Comprobación rápida

¿Qué hace AsNoTracking() al realizar consultas con EF Core?

Repaso: conceptos básicos de DbContext y DbSet

Conceptos clave:

DbContext es la sesión con la base de datos; DbSet<T> representa una tabla
Regístrelo con AddDbContext en DI; de forma predeterminada, tiene el ámbito Scoped
Las consultas LINQ se ejecutan de forma diferida: ejecútelas con ToListAsync o FirstOrDefaultAsync
El seguimiento de cambios permite realizar UPDATE/DELETE automáticamente mediante SaveChangesAsync
Use AsNoTracking() en consultas de solo lectura para mejorar el rendimiento

Preguntas frecuentes

¿La lección «Fundamentos de DbContext y DbSet» es gratis?

Sí — el texto completo de «Fundamentos de DbContext y DbSet» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Fundamentos de DbContext y DbSet»?

Configure un DbContext, defina entidades, configure la cadena de conexión y ejecute su primera consulta. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de DbContext y DbSet»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy