Performance bottlenecks in EF Core usually result from inefficient queries, tracking overhead, poor caching strategies, or a lack of profiling. This guide expands significantly on the core areas of performance optimization, giving you practical, hands-on advice, code examples, tools, and diagnostics to elevate the performance of your EF Core-powered applications.

Why Performance Matters in EF Core

Entity Framework Core simplifies data access, but abstraction often comes at a cost. Poor EF Core usage can lead to massive performance degradation:

• Slow page loads due to unoptimized queries
• Unnecessary memory consumption from tracking
• Full table scans due to lack of indexes
• Unexpected timeouts on production systems

Understanding how EF Core behaves under the hood is the first step to making smarter design decisions.

Crafting Efficient Queries

Problem:

Using ToList() on a DbSet without filtering loads all data into memory—terrible for scalability.

Bad:

var users = dbContext.Users.ToList(); // Loads all user data

Better:

var names = dbContext.Users.Select(u => u.Name).ToList(); // Loads only names

Best:

var names = await dbContext.Users
    .Where(u => u.IsActive)
    .OrderBy(u => u.Name)
    .Select(u => new { u.Id, u.Name })
    .ToListAsync();

Use filters, projections, sorting, and asynchronous queries.

Tip: Avoid fetching navigation properties unless needed. Use Include() selectively.

var orders = dbContext.Orders
    .Include(o => o.Customer)
    .Where(o => o.Status == "Shipped")
    .ToList();

Leveraging Query Splitting and NoTracking

Tracking Overhead:

By default, EF Core tracks all retrieved entities. This consumes memory and CPU.

Solution:

var orders = dbContext.Orders
    .AsNoTracking()
    .Where(o => o.Status == "Shipped")
    .ToList();

Use .AsNoTracking() for read-only queries.

Query Splitting:

Avoid the Cartesian explosion problem when loading multiple navigation properties:

var customers = dbContext.Customers
    .Include(c => c.Orders)
    .AsSplitQuery() // Recommended in EF Core 5+
    .ToList();

Optimizing LINQ Expressions

Avoid Inefficient Operations:

Calling .ToList() before .Where() fetches all records into memory.

Bad:

var filtered = dbContext.Users.ToList().Where(u => u.IsActive); // Inefficient

Good:

var filtered = dbContext.Users.Where(u => u.IsActive).ToList();

Advanced Caching Techniques

EF Core does not include a built-in second-level cache. Implement caching manually or with libraries like EFCoreSecondLevelCacheInterceptor.

Example with IMemoryCache:

var users = await memoryCache.GetOrCreateAsync("users", entry =>
{
    entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10);
    return dbContext.Users.Where(u => u.IsActive).ToListAsync();
});

Redis Example:

Use StackExchange.Redis and serialize data:

await redis.StringSetAsync("users", JsonConvert.SerializeObject(userList));

Comprehensive Indexing Strategies

Indexing is often overlooked until performance issues arise. Analyze slow queries with execution plans and ensure indexes support WHERE and JOIN clauses.

SQL Example:

CREATE NONCLUSTERED INDEX IX_Orders_CustomerId ON Orders(CustomerId);

EF Core Fluent API:

modelBuilder.Entity<Order>()
    .HasIndex(o => o.CustomerId);

Use EF Core migrations to keep your indexes under version control.

Profiling and Monitoring

Don’t guess—measure. Use profiling to discover real bottlenecks.

Tools:

• MiniProfiler: Lightweight and easy to integrate
• EF Core Logging: Use LogTo() to inspect SQL output
• SQL Server Profiler: Deep analysis of database interactions

EF Core Logging Example:

optionsBuilder.LogTo(Console.WriteLine, LogLevel.Information)
              .EnableSensitiveDataLogging();

Connection Pooling and DbContext Lifetime

• Reuse DbContext instances within a logical unit of work.
• Don’t keep DbContext alive longer than necessary.

Best Practice:

Inject DbContext with scoped lifetime in ASP.NET Core:

services.AddDbContext<MyAppContext>(options =>
    options.UseSqlServer(Configuration["ConnectionStrings:Default"]));

Avoiding N+1 Query Problems

EF Core doesn’t automatically batch related data queries. Loading related data inside a loop triggers extra queries:

Problem:

foreach (var order in dbContext.Orders)
{
    var customer = dbContext.Customers.Find(order.CustomerId); // Extra query per loop
}

Fix:

var ordersWithCustomers = dbContext.Orders
    .Include(o => o.Customer)
    .ToList();

Batching and Transactions

Batch inserts, updates, and deletes reduce round trips and improve throughput.

Batch Save:

foreach (var order in orders)
{
    dbContext.Orders.Add(order);
}
await dbContext.SaveChangesAsync();

Use TransactionScope or explicit transactions for grouped operations:

using var transaction = await dbContext.Database.BeginTransactionAsync();
try
{
    await dbContext.SaveChangesAsync();
    await transaction.CommitAsync();
}
catch
{
    await transaction.RollbackAsync();
    throw;
}

Schema Optimization

Schema design impacts EF Core performance:

• Normalize where appropriate but avoid excessive joins.
• Use appropriate data types.
• Apply constraints (e.g., unique indexes) to enforce business rules at the DB level.

Summary

Optimizing EF Core is about being intentional with every layer—from LINQ queries and DbContext usage to caching and SQL indexing. Use the tools available, monitor proactively, and always validate changes with performance testing.

These techniques, when applied consistently, can result in:

• Faster page loads
• Lower memory usage
• Reduced database contention
• Happier users (and developers!)