Top 10 Techniques to Optimize Entity Framework (EF) Queries in .NET Core for Faster 🚀Performance

Entity Framework Core (EF Core) is the go-to ORM for .NET developers building modern web applications. Its ease of use, LINQ support, and powerful abstraction over SQL make it a favorite. But with great power comes great responsibility — especially when it comes to performance.

Unoptimized EF queries can quickly become bottlenecks, slowing down your ASP.NET Core applications and frustrating users. Whether you’re building APIs, web apps, or microservices, understanding how to optimize EF Core queries is crucial for scalable, responsive software.

In this post, I’ll walk you through the 10 best techniques to optimize EF Core queries, complete with explanations, code snippets, and practical advice. Let’s make your .NET code fly!

Why EF Query Optimization Matters

EF Core abstracts away the database layer, letting you work with C# objects instead of raw SQL. But this abstraction can hide inefficient queries, unnecessary data loading, and poor database usage. Here’s why optimization is essential:

• Performance: Slow queries mean slow apps. Users expect instant responses.
• Scalability: Optimized queries handle more users and data without breaking a sweat.
• Cost: Inefficient queries can increase cloud/database costs.
• Developer Experience: Clean, fast queries are easier to maintain and debug.

Let’s dive into the techniques that will supercharge your EF Core queries.

1. Use AsNoTracking() for Read-Only Queries

EF Core tracks changes to entities by default, which is great for updates but unnecessary for read-only scenarios. Tracking adds overhead and memory usage.

Explanation:
AsNoTracking() tells EF Core not to track entities, boosting performance for queries where you don’t intend to update the data.

Code Example:

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

Benefits:

• Faster query execution.
• Lower memory consumption.

Trade-Offs:

• You can’t update or delete entities directly after fetching.

When to Apply:

• Use for read-only queries (e.g., API GET endpoints, dashboards).

2. Avoid SELECT *: Use Select() for Specific Columns

Fetching all columns (SELECT *) loads unnecessary data, especially with wide tables. This impacts network, memory, and performance.

Explanation:
Project only needed columns using LINQ’s Select() method.

Code Example:

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

Benefits:

• Reduces data transfer.
• Speeds up queries and serialization.

Trade-Offs:

• May require more mapping if you need full entities later.

When to Apply:

• When you only need a subset of columns (e.g., for lists or summaries).

3. Optimize Relationships: Avoid N+1 Queries with Include() / ThenInclude()

Loading related entities can cause the dreaded N+1 problem — multiple queries for each parent entity.

Explanation:
Use Include() and ThenInclude() to eagerly load related data in a single query.

Code Example:

var orders = dbContext.Orders
    .Include(o => o.Customer)
    .Include(o => o.OrderItems)
        .ThenInclude(oi => oi.Product)
    .ToList();

Benefits:

• Minimizes number of queries.
• Reduces database round-trips.

Trade-Offs:

• Can load more data than needed if not careful.

When to Apply:

• When you need related data for display or processing.

4. Use Compiled Queries for Hot Paths

Repeated queries can benefit from compilation, reducing overhead.

Explanation:
EF Core can compile queries for reuse, minimizing parsing and planning time.

Code Example:

private static readonly Func<MyDbContext, int, Product> _getProductById =
    EF.CompileQuery((MyDbContext context, int id) =>
        context.Products.FirstOrDefault(p => p.Id == id));

var product = _getProductById(dbContext, 42);

Benefits:

• Faster execution for frequent queries.

Trade-Offs:

• Less flexibility (parameters must match signature).

When to Apply:

• For queries executed repeatedly in performance-critical paths.

5. Apply Pagination with Skip() and Take()

Loading thousands of records at once kills performance and user experience.

Explanation:
Use Skip() and Take() for paging, loading only what’s needed.

Code Example:

var pageSize = 20;
var pageNumber = 2;

var productsPage = dbContext.Products
    .OrderBy(p => p.Id)
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToList();

Benefits:

• Reduces memory and network usage.
• Improves scalability.

Trade-Offs:

• Complex paging (e.g., with filters) may require extra logic.

When to Apply:

• For any list or grid UI, API endpoints, or large datasets.

6. Use Batching and Bulk Operations

EF Core’s default SaveChanges() issues one query per entity. For large inserts/updates, this is slow.

Explanation:
Use batching, or third-party libraries (e.g., EFCore.BulkExtensions), to perform bulk operations.

Code Example:

// Using EFCore.BulkExtensions
dbContext.BulkInsert(largeListOfProducts);

Benefits:

• Drastically faster for bulk inserts/updates/deletes.

Trade-Offs:

• Third-party libraries may lack some features or require learning curve.

When to Apply:

• For data migrations, imports, or batch jobs.

7. Leverage Caching Strategies

Querying the database for the same data over and over wastes resources.

Explanation:
Cache frequently accessed data using memory cache, distributed cache, or third-party solutions.

Code Example:

// Using IMemoryCache
if (!cache.TryGetValue("products", out List<Product> products))
{
    products = dbContext.Products.AsNoTracking().ToList();
    cache.Set("products", products, TimeSpan.FromMinutes(10));
}

Benefits:

• Reduces database load.
• Improves response times.

Trade-Offs:

• Must handle cache invalidation carefully.

When to Apply:

• For reference data, lookups, or expensive queries.

8. Keep Queries Simple: Push Logic to the Database

Complex queries in C# can force EF Core to pull data into memory, then process it — slow and inefficient.

Explanation:
Use LINQ methods that translate to SQL (Where, Select, Any, etc.), and avoid client-side evaluation.

Code Example:

// Good: runs entirely in SQL
var activeProducts = dbContext.Products
    .Where(p => p.IsActive && p.Stock > 0)
    .ToList();

// Bad: runs in memory
var products = dbContext.Products.ToList();
var filtered = products.Where(p => SomeComplexMethod(p)).ToList();

Benefits:

• Maximizes database efficiency.
• Minimizes data transfer.

Trade-Offs:

• Some logic may be hard to express in SQL.

When to Apply:

• Always prefer server-side filtering and processing.

9. Use Indexes in SQL Server Wisely

EF Core generates SQL, but database performance depends heavily on proper indexing.

Explanation:
Create indexes on columns used in WHERE, ORDER BY, or joins.

Code Example:

-- SQL Server: Add index on Product.IsActive
CREATE INDEX IX_Products_IsActive ON Products(IsActive);

Or via EF Core migration:

modelBuilder.Entity<Product>()
    .HasIndex(p => p.IsActive);

Benefits:

• Speeds up queries and lookups.

Trade-Offs:

• Too many indexes slow down inserts/updates.

When to Apply:

• For frequently queried/filter columns.

10. Profile Queries with Tools Like EF Profiler or SQL Server Profiler

You can’t optimize what you don’t measure.

Explanation:
Use profiling tools to analyze queries, find bottlenecks, and optimize.

Popular Tools:

• EF Core Logging
• SQL Server Profiler
• MiniProfiler
• EF Profiler

Code Example:

// Enable EF Core logging
var options = new DbContextOptionsBuilder<MyDbContext>()
    .LogTo(Console.WriteLine)
    .Options;

Benefits:

• Identifies slow queries and N+1 issues.
• Provides actionable insights.

Trade-Offs:

• Profiling adds overhead; use in dev/test environments.

When to Apply:

• During development, performance tuning, or troubleshooting.

Conclusion: Best Practices for EF Core Query Optimization

Optimizing EF Core queries is essential for building fast, scalable .NET applications. Here’s a quick recap:

• Use AsNoTracking() for read-only queries.
• Project only needed columns with Select().
• Prevent N+1 queries with Include()/ThenInclude().
• Compile hot-path queries.
• Always paginate with Skip()/Take().
• Use batching and bulk operations for large data jobs.
• Cache frequently accessed data.
• Keep logic in the database, not in C#.
• Create indexes for fast lookups.
• Profile regularly to catch and fix issues.

Measure, monitor, and optimize continuously. Every application is different — profile your queries, understand your data, and apply these techniques where they make the most impact.

Happy coding! 🚀

👋Ultimate Collection of .NET Web Apps for Developers and Businesses
🚀 My YouTube Channel
💻 Github

Here are three ways you can help me out:
Please drop me a follow →👍 R M Shahidul Islam Shahed
Receive an e-mail every time I post on Medium → 💌 Click Here
Grab a copy of my E-Book on OOP with C# → 📚 Click Here