Supercharge .NET EF Core: 5 Performance Secrets for 2025

// The old way, re-evaluating the query structure each time
var product = await dbContext.Products.FirstOrDefaultAsync(p => p.Id == productId);

// The compiled way: define it once, statically
private static readonly Func<ProductDbContext, int, Task<Product>> _getProductById =
    EF.CompileAsyncQuery((ProductDbContext context, int id) =>
        context.Products.FirstOrDefault(p => p.Id == id));

// Then call it anywhere, with near-zero overhead
var product = await _getProductById(dbContext, productId);

var blogs = await dbContext.Blogs
    .Include(b => b.Posts)
    .ThenInclude(p => p.Tags)
    .ToListAsync();

The Solution: AsSplitQuery to the Rescue

EF Core provides a simple, elegant solution: AsSplitQuery(). By adding this one method to your query, you tell EF Core to be smarter.

var blogs = await dbContext.Blogs
    .Include(b => b.Posts)
    .ThenInclude(p => p.Tags)
    .AsSplitQuery() // The magic happens here!
    .ToListAsync();

Instead of one giant, bloated query, EF Core now generates multiple, leaner SQL queries. The first query fetches the blogs, the next fetches all the posts for those blogs, and another fetches all the tags. It then stitches them together in memory. While this means more database round-trips, it's often dramatically faster because the total amount of data transferred is a fraction of the single-query approach.

Pro Tip: Use split queries when you are including more than one collection. For single-collection includes, the default single query is usually fine. Profile both to be sure!

Secret #3: Bypass the Change Tracker with ExecuteUpdate & ExecuteDelete

The traditional way to update or delete entities is a three-step process: fetch, modify, save.

var productsToDiscount = await dbContext.Products
    .Where(p => p.Category == "OldStock")
    .ToListAsync();

foreach (var product in productsToDiscount)
{
    product.Price *= 0.8m; // Apply 20% discount
}

await dbContext.SaveChangesAsync();

This is fine for a few records. But for hundreds or thousands? You're pulling all that data into memory, tracking every single change, and then sending individual update commands back to the database. It's incredibly inefficient.

Enter ExecuteUpdate and ExecuteDelete. These methods, introduced in EF Core 7, are absolute game-changers. They allow you to perform bulk operations directly in the database, completely bypassing the change tracker.

// One command, zero tracking overhead, instant execution.
var rowsAffected = await dbContext.Products
    .Where(p => p.Category == "OldStock")
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.Price, p => p.Price * 0.8m));

This generates a single, efficient SQL UPDATE statement. The performance difference isn't just linear; it's exponential. What took minutes can now take milliseconds. If you're not using these for bulk operations in 2025, you're leaving a massive amount of performance on the table.

Secret #4: Think AOT-First for Cloud-Native Speed

With .NET 8, Ahead-of-Time (AOT) compilation went from a niche feature to a mainstream powerhouse, especially for serverless functions and containerized microservices. Native AOT offers lightning-fast startup times and a drastically reduced memory footprint.

However, this performance comes with a trade-off: it requires your code to be statically analyzable. EF Core, with its heavy use of reflection and dynamic expression building, can be tricky in an AOT world. A query that works perfectly in a JIT-compiled app might fail at runtime in a Native AOT environment.

The secret for 2025 is to start thinking "AOT-first." This means writing queries that are trim-safe and AOT-compatible from the beginning.

• Avoid dynamic query construction: Steer clear of building expression trees manually at runtime if you can.
• Use compiled models: This pre-computes the model at build time, significantly improving startup performance, which is critical for AOT. You can enable this with a single line in your `DbContext`'s `OnConfiguring` or via dependency injection.
• Test with the AOT analyzer: The .NET SDK includes an analyzer that will warn you about AOT-incompatible code. Pay attention to it!

By adopting an AOT-friendly mindset, you're not just optimizing for a specific deployment target; you're writing cleaner, more explicit, and often more performant code for all environments.

Secret #5: Embrace the Hybrid Approach with Raw SQL

This might sound counterintuitive in an EF Core article, but one of the biggest secrets to high performance is knowing when not to use LINQ.

EF Core is a tool, not a religion. For complex, read-heavy scenarios like reporting dashboards that involve intricate joins, window functions, or Common Table Expressions (CTEs), forcing it through LINQ can lead to convoluted code and suboptimal SQL. In these cases, dropping down to raw SQL is the pragmatic and performant choice.

EF Core makes this easy and safe with FromSqlRaw or FromSqlInterpolated, which still provide object materialization and protection against SQL injection.

// A complex query that's much clearer in SQL
var report = await dbContext.MonthlySalesReport
    .FromSql($@"WITH SalesCTE AS (
        SELECT ProductId, YEAR(OrderDate) as SaleYear, MONTH(OrderDate) as SaleMonth, SUM(Total) as MonthlyTotal
        FROM Orders
        GROUP BY ProductId, YEAR(OrderDate), MONTH(OrderDate)
    )
    SELECT * FROM SalesCTE WHERE SaleYear = {year} AND SaleMonth = {month}")
    .ToListAsync();

The true expert isn't the one who can write the most complex LINQ query; it's the one who knows the most effective tool for the job. Combining the convenience of EF Core for 90% of your CRUD operations with the raw power of SQL for the remaining 10% is the hallmark of a seasoned .NET developer.

---

Putting It All Together

Performance tuning in EF Core is a journey of continuous discovery. It's not about applying a single magic bullet, but about understanding the underlying mechanics and making conscious, informed decisions. By compiling your hot-path queries, splitting your includes, using bulk operations, thinking AOT-first, and knowing when to reach for raw SQL, you can transform your EF Core-powered applications from sluggish to spectacular.

Stop letting the ORM be a black box. Dive in, master these techniques, and build the fastest, most scalable .NET applications of your career.