C# Academy · Lección

Operaciones CRUD con EF Core

Realice operaciones de Create, Read, Update y Delete mediante el seguimiento de cambios de EF Core y SaveChanges.

Lección 3 de 413 pasos

Operaciones CRUD con EF Core es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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.

Descripción general de CRUD en EF Core

EF Core gestiona las cuatro operaciones CRUD: crear, leer, actualizar y eliminar, mediante una combinación del seguimiento de cambios y SaveChangesAsync(). Comprender el seguimiento de cambios es fundamental para dominar CRUD.

Crear: agregar una entidad nueva

Use DbSet.Add() o AddAsync() para marcar una entidad como Added. Al llamar a SaveChangesAsync(), EF Core genera un INSERT y rellena la clave 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

Agregar un grafo de entidades

Al agregar un elemento principal con sus elementos secundarios en una sola llamada, se inserta todo el grafo de objetos. EF Core resuelve automáticamente las relaciones de clave foránea.

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

Leer: consultar con LINQ

EF Core traduce las expresiones LINQ a SQL. Componga consultas con Where, Select, OrderBy, etc., y materialícelas con ToListAsync o 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();

Leer: buscar una sola entidad

Para leer una sola entidad, use FindAsync (comprueba primero el seguimiento) o FirstOrDefaultAsync / SingleOrDefaultAsync con un 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();

Actualizar: seguimiento de cambios

EF Core realiza el seguimiento de las entidades cargadas. Modifique las propiedades directamente y llame a SaveChangesAsync(). EF Core detecta las diferencias y genera una instrucción 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

Actualizar: actualización en bloque (EF Core 7+)

ExecuteUpdateAsync actualiza las filas directamente en la base de datos sin cargar las entidades. Es mucho más eficaz para operaciones en bloque.

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

Eliminar: quitar una sola entidad

Llame a Remove() sobre una entidad cuyo seguimiento se esté realizando y, después, a SaveChangesAsync(). Si solo tiene el ID, búsquela primero o 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

Eliminar: eliminación en bloque (EF Core 7+)

ExecuteDeleteAsync emite una sola instrucción SQL DELETE sin cargar las entidades, lo que resulta ideal para operaciones de limpieza por lotes.

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

Transacciones

Todas las operaciones realizadas dentro de una única llamada a SaveChangesAsync se incluyen en una transacción. Para operaciones de varios pasos repartidas entre varios guardados, use una transacción 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;
}

En la práctica: servicio CRUD completo

Un servicio completo encapsula todas las operaciones CRUD con un manejo adecuado de errores y devuelve DTO para evitar exponer los detalles internos de las 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;
}

Comprobación rápida

¿Qué ventaja ofrecen ExecuteUpdateAsync / ExecuteDeleteAsync frente a cargar las entidades y llamar a SaveChangesAsync?

Responde en la lección interactiva

Repaso: operaciones CRUD con EF Core

Conceptos clave:

Add + SaveChangesAsync → INSERT; EF Core rellena las claves autogeneradas
Modificar entidades cuyo seguimiento se realiza + SaveChangesAsync → UPDATE mínimo
Remove + SaveChangesAsync → DELETE para entidades individuales
ExecuteUpdateAsync / ExecuteDeleteAsync → operaciones en bloque sin cargar entidades (EF Core 7+)
Incluya las operaciones de varios pasos en una transacción explícita para garantizar la atomicidad

Gratis para empezar

Aprende C# con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 93
Lecciones: 346

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Operaciones CRUD con EF Core» es gratis?

Sí — el texto completo de «Operaciones CRUD con EF Core» 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 «Operaciones CRUD con EF Core»?

Realice operaciones de Create, Read, Update y Delete mediante el seguimiento de cambios de EF Core y SaveChanges. 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 3 de 4.

¿Cuánto tiempo toma la lección «Operaciones CRUD con EF Core»?

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