Entity Framework: Advanced Topics

Dive deeper into advanced features of Entity Framework Core, optimizing performance, handling complex scenarios, and leveraging its full potential for enterprise-level applications.

1. Performance Optimization Techniques

Optimizing database interactions is crucial for application responsiveness. Entity Framework provides several ways to achieve this.

1.1. Eager Loading vs. Lazy Loading vs. Explicit Loading

Understanding how related entities are loaded can significantly impact performance.

• Eager Loading: Use the .Include() and .ThenInclude() extension methods to load related data in a single query.
• Lazy Loading: Requires virtual navigation properties and the Microsoft.EntityFrameworkCore.Proxies package. It loads related data on demand, which can be convenient but may lead to N+1 query problems if not managed carefully.
• Explicit Loading: Use .Entry().Collection().Load() or .Entry().Reference().Load() to manually load related data when needed.

For performance-critical scenarios, eager loading is generally preferred over lazy loading to avoid multiple round trips to the database.

1.2. Projection with Select

Instead of loading entire entities and then selecting properties, use .Select() to project only the data you need. This reduces the amount of data transferred from the database.

var productSummaries = dbContext.Products
    .Where(p => p.IsActive)
    .Select(p => new { p.Id, p.Name, p.Price })
    .ToList();
            

1.3. AsNoTracking()

When querying data for read-only purposes, use .AsNoTracking() to prevent EF Core from tracking entities. This bypasses change tracking overhead, improving read performance.

var allActiveProducts = dbContext.Products
    .AsNoTracking()
    .Where(p => p.IsActive)
    .ToList();
            

1.4. Batch Operations

For bulk inserts, updates, or deletes, consider using EF Core's batching capabilities (available via NuGet packages like EFCore.BulkExtensions) which can execute operations in fewer database calls.

2. Advanced Querying and Data Manipulation

2.1. Raw SQL Queries

Sometimes, you might need to write raw SQL queries for performance or to utilize database-specific features. EF Core allows you to execute raw SQL and map the results back to entities or DTOs.

var customers = dbContext.Customers.FromSqlRaw("SELECT * FROM dbo.Customers WHERE City = {0}", "London").ToList();

var orderCount = dbContext.Database.ExecuteSqlRaw("UPDATE dbo.Orders SET Status = 'Shipped' WHERE OrderDate < {0}", DateTime.Now.AddDays(-30));
            

2.2. Stored Procedures

You can call stored procedures using FromSqlInterpolated or ExecuteSqlInterpolated for input parameters.

var productsByPrice = dbContext.Products.FromSqlInterpolated($"EXEC dbo.GetProductsByPriceRange {minPrice}, {maxPrice}").ToList();
            

2.3. Working with Large Object (LOB) Data

Efficiently handling large data like images or large text fields requires careful consideration. EF Core can map these to appropriate database types.

3. Concurrency Control

3.1. Optimistic Concurrency

This is the most common approach. It involves detecting if a row has been changed by another user since it was read.

• RowVersion/Timestamp: Add a property (e.g., byte[] RowVersion) to your entity and mark it with [Timestamp]. EF Core will automatically manage this for optimistic concurrency checks.
• Property-Based Concurrency: You can also implement concurrency checking based on specific properties.

When a concurrency conflict occurs, EF Core throws a DbUpdateConcurrencyException. You can catch this exception and implement retry logic or allow the user to resolve the conflict.

3.2. Pessimistic Concurrency

Less common with EF Core directly, but can be implemented using database-level locking mechanisms. This blocks other users from modifying the data while it's being edited.

4. Migrations Advanced Scenarios

4.1. Multiple Migrations

EF Core Migrations allow you to version your database schema. You can manage multiple migrations, revert to previous states, or generate scripts.

dotnet ef migrations add InitialCreate
dotnet ef migrations add AddUserTable
dotnet ef database update
            

4.2. Data Seeding

Use the HasData() method in your OnModelCreating configuration to seed initial data into your database when migrations are applied.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity().HasData(
        new Role { Id = 1, Name = "Admin" },
        new Role { Id = 2, Name = "User" }
    );
}
            

4.3. Scripting Migrations

Generate SQL scripts for migrations, which is useful for deploying changes to production environments.

dotnet ef migrations script
            

5. Global Query Filters

Apply filters to all queries of a certain entity type globally. A common use case is soft deletes.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity().HasQueryFilter(p => !p.IsDeleted);
}
            

When IsDeleted is true, the product will not appear in regular queries against the Products DbSet. You can bypass this filter for administrative purposes.

6. Interceptors

Interceptors allow you to hook into EF Core's operations (like saving changes or executing commands) to add cross-cutting concerns such as logging, auditing, or modifying queries.

This is a powerful feature for customizing EF Core's behavior without modifying its core components.

Conclusion

Mastering these advanced Entity Framework concepts will empower you to build robust, high-performance data access layers for your .NET applications. Always benchmark and profile your queries to ensure optimal performance in your specific application context.