Mastering Performance Tuning and Best Practices in Entity Framework Core 9

With the introduction of .NET 9, EF has seen improvements, offering new features and optimizations to boost performance. However, to harness its full potential, developers must follow best practices and optimize their code.

In this article, we'll cover essential best practices for working with Entity Framework in .NET 9, along with tips for improving your application's performance.

1. Use AsNoTracking for Read-Only Queries

EF tracks changes to entities by default, but this can be unnecessary for read-only queries. Using AsNoTracking() improves performance by reducing memory usage and the overhead of change tracking.

var products = dbContext.Products.AsNoTracking().Where(p => p.Price > 50).ToList();

2. Leverage Eager Loading Appropriately

Use explicit eager loading with Include to fetch related entities in one query, thus avoiding the N+1 problem. However, lazy loading can lead to performance overhead if not controlled.

var orders = await dbContext.Orders.Include(o => o.OrderDetails).ToListAsync();

3. Use Projections to Retrieve Only Needed Data

Instead of fetching entire entity graphs, project only the necessary fields using Select to avoid over-fetching data.

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

4. Optimize Repeated Queries with Compiled Queries

.NET 9 introduces improved support for compiled queries, which can enhance performance by caching query execution plans. This is beneficial for frequently executed queries.

private static readonly Func<MyDbContext, int, Order?> GetOrderById =
    EF.CompileQuery((MyDbContext context, int id) =>
        context.Orders.FirstOrDefault(o => o.Id == id));

var order = GetOrderById(dbContext, 2);

5. Ensure Proper Indexing for Faster Queries

Ensure that your database schema includes indexes for frequently queried fields. Lack of indexing can lead to slow query performance even when your EF code is well-optimized.

[Index(nameof(Username), IsUnique = true)]
public class User {
    public int Id { get; set; }
    public string Username { get; set; }
}

6. Use Lazy Loading Cautiously

While lazy loading can be convenient, it may lead to unexpected multiple queries. Explicit loading is often better for controlling when and how related data is fetched.

var product = dbContext.Products.Find(1);
dbContext.Entry(product).Collection(p => p.Reviews).Load();

7. Optimize Connection Pooling

With .NET 9, connection pooling is improved. Make sure to configure connection pooling settings, such as MinPoolSize and MaxPoolSize, in your connection string to reduce database connection overhead.

var optionsBuilder = new DbContextOptionsBuilder<MyDbContext>();
optionsBuilder.UseSqlServer("Server=myServer;Database=myDB;User Id=myUser;Password=myPass;Min Pool Size=5;Max Pool Size=100;");

8. Take Advantage of Asynchronous Operations

Use asynchronous methods like ToListAsync(), FirstOrDefaultAsync(), and SaveChangesAsync() to prevent blocking threads, enhancing the scalability and responsiveness of your application.

var employees = await dbContext.Employees.ToListAsync();

9. Enable Connection Resiliency for Better Fault Tolerance

Enable connection resiliency to automatically retry failed database operations, helping to handle transient errors gracefully.

optionsBuilder.UseSqlServer(
    connectionString,
    options => options.EnableRetryOnFailure());

10. Use Batch Operations for Updates and Deletes

.NET 9 introduces support for batch updates and deletes, which can reduce the overhead of executing individual queries for each record. Use ExecuteUpdate and ExecuteDelete to perform bulk operations.

dbContext.Products
    .Where(p => p.Stock < 5)
    .ExecuteUpdate(p => p.SetProperty(x => x.Price, x => x.Price * 1.2));

Additional Performance Optimization Tips:

1. Use Transactions for Multiple Changes Ensure data consistency and improve performance by grouping multiple changes in a transaction.

using var transaction = dbContext.Database.BeginTransaction();
try {
    dbContext.Orders.Add(new Order { ... });
    dbContext.SaveChanges();
    transaction.Commit();
} catch {
    transaction.Rollback();
}

2. Implement Pagination for Large Queries For queries that could return a large number of results, use pagination to limit the number of records returned at once.

var pageSize = 20;
var pageNumber = 3;
var paginatedProducts = dbContext.Products
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToList();

3. Use Stored Procedures for Complex Queries For complex or performance-critical queries, stored procedures can often outperform ORM-based queries. Use FromSqlRaw to execute stored procedures.

var products = dbContext.Products.FromSqlRaw("EXEC GetTopSellingProducts").ToList();

4. Disable Change Tracking for Bulk Reads For queries where no updates are needed, disable change tracking to reduce overhead.

dbContext.ChangeTracker.AutoDetectChangesEnabled = false;

5. Reduce Database Round-Trips with Bulk Operations Use extensions like EFCore.BulkExtensions to perform bulk inserts, updates, and deletes in a single database call.

await dbContext.BulkInsertAsync(newProducts);
await dbContext.BulkUpdateAsync(updatedProducts);

6. Profile Queries Using Database Tools Use profiling tools like SQL Server Profiler or PostgreSQL's EXPLAIN ANALYZE to identify slow queries and optimize them.

7. Use JSON Columns for Schema-Less Data For storing flexible or non-relational data, JSON columns are a good choice.

public class Product {
    public int Id { get; set; }
    public string Name { get; set; }
    public string FeaturesJson { get; set; } // Store JSON data
}

8. Keep EF Core Updated Regularly update to the latest version of EF Core to benefit from performance optimizations and new features introduced in .NET 9.

9. Limit AutoMapper Usage for Critical Paths While AutoMapper is convenient for mapping entities to DTOs, excessive use can affect performance. Consider manual mapping in performance-sensitive areas.

Entity Framework Core is a robust and flexible ORM, but its performance depends heavily on how it is utilized. By following the best practices outlined here and leveraging new improvements in .NET 9, you can build applications that are both performant and scalable.