Entity Framework  

How to Improve Entity Framework Core Query Performance?

Introduction

Entity Framework Core (EF Core) is a powerful ORM for .NET applications, allowing developers to interact with databases using LINQ instead of SQL. However, if not used carefully, EF Core queries can become slow, especially with large tables and complex relationships. The good news? There are many simple techniques that can help you improve EF Core performance significantly. In this article, you will learn practical tips—written in plain and natural language—to optimize your EF Core queries and make your .NET applications run faster.

Use AsNoTracking for Read-Only Queries

Tracking changes adds overhead. If you’re only reading data, disable tracking.

Example (Slow)

var users = await _context.Users.ToListAsync();

Optimized

var users = await _context.Users.AsNoTracking().ToListAsync();

Why It Helps

  • Reduces memory usage

  • Improves query execution speed

  • Recommended for all read-only operations

Select Only the Columns You Need (Projections)

Fetching entire entities loads unnecessary columns.

Slow Query

var users = await _context.Users.ToListAsync();

Efficient Query

var users = await _context.Users
    .Select(u => new { u.Id, u.Name })
    .ToListAsync();

Benefits

  • Smaller payload

  • Faster network transfer

  • Reduced materialization overhead

Use Pagination for Large Result Sets

Never return thousands of rows at once.

Example

var page = 1;
var pageSize = 20;

var users = await _context.Users
    .Skip((page - 1) * pageSize)
    .Take(pageSize)
    .ToListAsync();

Why It Helps

  • Reduces memory usage

  • Prevents slow UI loading

Avoid N+1 Query Problems with Include

If you load related data in a loop, EF will run multiple queries.

Bad (N+1 queries)

var users = await _context.Users.ToListAsync();
foreach (var user in users)
{
    var orders = user.Orders; // triggers additional queries
}

Good

var users = await _context.Users
    .Include(u => u.Orders)
    .ToListAsync();

Why It Matters

  • Prevents unnecessary round trips to the database

Use Filter Before Include (Important)

Filtering after Include loads unnecessary data.

Inefficient

var users = await _context.Users
    .Include(u => u.Orders)
    .Where(u => u.IsActive)
    .ToListAsync();

Optimized

var users = await _context.Users
    .Where(u => u.IsActive)
    .Include(u => u.Orders)
    .ToListAsync();

Why This Helps

  • Does not fetch extra records

  • Reduces memory and improves SQL execution

Index Database Columns Properly

Indexes drastically improve filtering and lookups.

Add Index in Entity

[Index(nameof(Email), IsUnique = true)]
public class User { ... }

Performance Impact

  • Faster queries on WHERE clauses

  • Better JOIN performance

Avoid Client Evaluation (Let Database Do the Work)

EF Core may switch to client-side evaluation if query contains unsupported logic.

Bad

var users = await _context.Users
    .Where(u => SomeCSharpFunction(u.Name)) // runs on client
    .ToListAsync();

Good

var users = await _context.Users
    .Where(u => u.Name.Contains(search)) // SQL compatible
    .ToListAsync();

Why This Matters

  • Client-side evaluation slows down performance

  • Database engines are optimized for filtering

Use Compiled Queries for Frequently Used Queries

If a query runs millions of times, precompile it.

Example

static readonly Func<AppDbContext, int, Task<User>> GetUserById =
    EF.CompileAsyncQuery((AppDbContext ctx, int id) =>
        ctx.Users.FirstOrDefault(u => u.Id == id));

Why It Helps

  • Reduces overhead of query translation

  • Useful for high-performance APIs

Avoid Using Lazy Loading (Prefer Explicit Loading)

Lazy loading causes hidden queries.

Bad

var user = await _context.Users.FirstAsync();
var orders = user.Orders; // triggers separate query

Good

var user = await _context.Users
    .Include(u => u.Orders)
    .FirstAsync();

Why

  • Lazy loading = more queries

  • Explicit loading = predictable performance

Keep Queries Simple and Use Raw SQL When Necessary

Sometimes LINQ creates inefficient SQL.

Example

var data = await _context.Users
    .FromSqlRaw("SELECT * FROM Users WHERE IsActive = 1")
    .ToListAsync();

When Useful

  • Extremely complex queries

  • Performance-critical reporting

Cache Frequently Requested Data

Use caching for data that rarely changes.

var cacheKey = "ActiveUsers";
if (!_memoryCache.TryGetValue(cacheKey, out List<User> users))
{
    users = await _context.Users.Where(u => u.IsActive).ToListAsync();
    _memoryCache.Set(cacheKey, users, TimeSpan.FromMinutes(10));
}

Why Cache?

  • Avoids hitting the database repeatedly

  • High performance gain for read-heavy systems

Disable Change Tracking for Bulk Operations

Manual tracking causes overhead in insert/update loops.

Efficient Bulk Insert

_context.ChangeTracker.AutoDetectChangesEnabled = false;
foreach (var record in records)
{
    _context.Add(record);
}
await _context.SaveChangesAsync();
_context.ChangeTracker.AutoDetectChangesEnabled = true;

Or Use Bulk Libraries

  • EFCore.BulkExtensions

  • Dapper + BulkCopy

Best Practices Summary

  • Use AsNoTracking for read-only queries

  • Use projections to select only required columns

  • Apply pagination for large datasets

  • Avoid N+1 problems with Include

  • Let the database handle filtering

  • Use compiled queries when necessary

  • Index your database properly

  • Prefer explicit loading over lazy loading

  • Cache frequently used data

  • Use raw SQL for complex cases

Conclusion

Improving EF Core query performance is all about reducing unnecessary work—both in your code and inside the database. By applying these practical tips like AsNoTracking, pagination, projections, correct indexing, and avoiding lazy loading, you can significantly speed up your application. With the right approach, EF Core becomes both powerful and performant for building fast, scalable .NET applications.

Membership not found