ExecuteUpdate and ExecuteDelete in EF Core – Faster Bulk Operations Without Loading Entities

When working with databases in EF Core, updating or deleting large amounts of data has always required loading entities into memory first. This approach works, but it is not efficient—especially when dealing with thousands of records.

To solve this, EF Core introduced two powerful methods:

• ExecuteUpdate
• ExecuteDelete

These methods allow direct database operations without loading entities into memory, making them faster and more efficient.

Before these methods, updating or deleting records typically looked like this:

var customers = await dbContext.Customers
    .Where(c => c.IsInactive)
    .ToListAsync();

dbContext.Customers.RemoveRange(customers);

await dbContext.SaveChangesAsync();

var customers = await dbContext.Customers
    .Where(c => c.IsInactive)
    .ToListAsync();

dbContext.Customers.RemoveRange(customers);

await dbContext.SaveChangesAsync();

Problems with this approach:

• Loads data into memory
• Uses change tracking (extra overhead)
• Multiple database round-trips
• Slower for large datasets

ExecuteUpdate and ExecuteDelete allow running SQL-like operations directly on the database.

• They do not load entities
• They do not use change tracking
• They execute as a single SQL query

Think of them as EF Core’s way of writing efficient bulk operations using LINQ.

These methods bring major improvements:

• Better performance – no unnecessary data loading
• Low memory usage – avoids tracking entities
• Single query execution – reduces database calls
• Cleaner code – no loops or manual processing

Use ExecuteUpdate to update records directly in the database.

Example: Increase price by 10%

await dbContext.Products
    .Where(p => p.Category == "Electronics")
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.Price, p => p.Price * 1.10));

await dbContext.Products
    .Where(p => p.Category == "Electronics")
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.Price, p => p.Price * 1.10));

What happens:

• Executes a single UPDATE query
• Applies changes to all matching records
• No entity tracking involved

Use ExecuteDelete when you want to delete records directly in the database.

Example: Delete inactive customers

await dbContext.Customers
    .Where(c => c.IsInactive)
    .ExecuteDeleteAsync();

await dbContext.Customers
    .Where(c => c.IsInactive)
    .ExecuteDeleteAsync();

What happens here:

• EF Core translates this into a single DELETE SQL query
• No data is loaded into memory
• No SaveChanges() is required

Both methods work with LINQ filters.

Example: Delete old orders

await dbContext.Orders
    .Where(o => o.CreatedDate < DateTime.UtcNow.AddYears(-1))
    .ExecuteDeleteAsync();

await dbContext.Orders
    .Where(o => o.CreatedDate < DateTime.UtcNow.AddYears(-1))
    .ExecuteDeleteAsync();

Only matching records will be affected.

You can update multiple columns in one operation.

await dbContext.Employees
    .Where(e => e.IsActive)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(e => e.Salary, e => e.Salary + 5000)
        .SetProperty(e => e.UpdatedAt, e => DateTime.UtcNow));

await dbContext.Employees
    .Where(e => e.IsActive)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(e => e.Salary, e => e.Salary + 5000)
        .SetProperty(e => e.UpdatedAt, e => DateTime.UtcNow));

Multiple fields updated in a single database call.

One important thing to understand is how change tracking works with these methods.

• EF Core does NOT track changes
• Tracked entities in memory are NOT updated automatically

If entities are already loaded:

var customer = await dbContext.Customers.FirstAsync();

await dbContext.Customers
    .Where(c => c.Id == customer.Id)
    .ExecuteUpdateAsync(s => s.SetProperty(c => c.Name, "Updated"));

var customer = await dbContext.Customers.FirstAsync();

await dbContext.Customers
    .Where(c => c.Id == customer.Id)
    .ExecuteUpdateAsync(s => s.SetProperty(c => c.Name, "Updated"));

The customer object in memory will still have the old value.

Always be careful when mixing tracked entities with these methods.

By default, each ExecuteUpdate or ExecuteDelete runs as a single database command.

Important points:

• Each call is executed immediately
• No need for SaveChanges()
• Runs in its own transaction (depending on provider)

If multiple operations need to be consistent:

using var transaction = await dbContext.Database.BeginTransactionAsync();

await dbContext.Orders
    .Where(o => o.IsExpired)
    .ExecuteDeleteAsync();

await dbContext.Products
    .Where(p => p.Stock == 0)
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.IsAvailable, false));

await transaction.CommitAsync();

using var transaction = await dbContext.Database.BeginTransactionAsync();

await dbContext.Orders
    .Where(o => o.IsExpired)
    .ExecuteDeleteAsync();

await dbContext.Products
    .Where(p => p.Stock == 0)
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.IsAvailable, false));

await transaction.CommitAsync();

This ensures all operations succeed or fail together.

• No change tracking
• No entity lifecycle events (like SavingChanges)
• No navigation property updates
• Immediate execution (no SaveChanges())

These methods are ideal when:

• Working with large datasets
• Performing bulk updates or deletes
• Optimizing performance-critical operations

• Archiving old data
• Soft deletes
• Bulk status updates
• Scheduled cleanup jobs

• Business logic depends on entity tracking
• Complex domain rules must run per entity

While ExecuteUpdate and ExecuteDelete are powerful, there are a few limitations to be aware of:

• No insert support – These methods only support update and delete operations. For inserting data, still use: DbSet<TEntity>.Add and SaveChanges().
• No access to affected row data – Even though SQL allows returning updated or deleted values, EF Core currently does not support retrieving those values with these methods.
• No batching across multiple calls – Each call to ExecuteUpdate or ExecuteDelete runs as a separate database roundtrip. Multiple calls are not combined into one query.
• Single table operations only – Most databases only allow updating or deleting from one table at a time, and these methods follow that rule.
• Relational databases only – These features work only with relational database providers (like SQL Server, PostgreSQL, MySQL). They are not supported in non-relational providers.

ExecuteUpdate and ExecuteDelete are powerful additions to EF Core that simplify bulk operations and improve performance.

Instead of loading data into memory, these methods execute operations directly in the database using a single query. This makes them ideal for high-performance applications.

• ExecuteUpdate and ExecuteDelete avoid loading entities
• They execute as a single SQL query
• No need for SaveChanges()
• Change tracking is bypassed
• Can be wrapped in transactions when needed
• Best for bulk operations and performance optimization