Deferred vs Immediate Execution in C#

Mastering Query Timing and Performance in LINQ

LINQ (Language Integrated Query) is one of C#’s most powerful features – it lets you query data in a consistent, readable way across arrays, lists, XML, or databases.

But there’s an important detail often missed by newcomers and even experienced developers:
When does a LINQ query actually run?

That’s the difference between Deferred Execution and Immediate Execution – and understanding it is essential for writing predictable, efficient code.

🔹 What Is Query Execution Timing?

When you create a LINQ query, you’re not necessarily running it.
Instead, you’re often building a query expression that defines what should happen later when you actually use it.

LINQ can behave in two distinct ways:

This difference affects both performance and correctness, especially when working with mutable collections or databases.

🔹 Deferred Execution

Definition

A deferred query is not executed at the moment you define it.
Instead, it’s executed when you enumerate it — such as during a foreach loop or when converting it into a collection.

Example

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Define query (not executed yet)
var query = numbers.Where(n => n > 2);

numbers.Add(6); // Modify data source before running

foreach (var n in query)
    Console.WriteLine(n);

Output:

3
4
5
6

✅ What’s Happening

• The query doesn’t run when defined.
• It runs later, at enumeration time (foreach).
• Because the source changed (Add(6)), the query reflects the new data.

Key Points

• Deferred execution is lazy — it waits until the results are needed.
• It always reflects the current state of the source.
• It’s memory efficient because data is processed on-demand.
• Most LINQ standard query operators (like Where, Select, and OrderBy) are deferred.

🔹 Immediate Execution

Definition

An immediate query executes as soon as it’s defined and stores the results into memory.
Any changes to the source afterwards won’t affect the query’s output.

Example

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Query executes immediately because of ToList()
var result = numbers.Where(n => n > 2).ToList();

numbers.Add(6); // Change source after query

foreach (var n in result)
    Console.WriteLine(n);

Output:

3
4
5

✅ What’s Happening

• .ToList() forces immediate execution.
• Results are materialized and stored.
• Later changes to numbers are ignored.

Common Immediate Operators

These methods cause LINQ to execute immediately:

• Materialisation methods: .ToList(), .ToArray(), .ToDictionary()
• Aggregation methods: .Count(), .Sum(), .Min(), .Max(), .Average(), .First(), .Single()

🔹 Comparing Deferred and Immediate Execution

🔹 Why It Matters

Understanding when your query runs affects:

• Performance: Deferred queries don’t waste resources until needed.
• Correctness: Modifying the source after defining a deferred query can change results or throw exceptions.
• Databases: In Entity Framework or LINQ-to-SQL, deferred queries delay hitting the database until data is actually accessed.

🔹 Practical Example – Side Effects and Timing

var data = new List<int> { 1, 2, 3 };

var query = data.Select(x =>
{
    Console.WriteLine($"Processing {x}");
    return x * 10;
});

Console.WriteLine("Before enumeration");
foreach (var item in query)
    Console.WriteLine($"Result: {item}");

Output:

Before enumeration
Processing 1
Result: 10
Processing 2
Result: 20
Processing 3
Result: 30

✅ Nothing happens until the loop begins — deferred execution in action.

Now try:

var query = data.Select(x => x * 10).ToList();

You’ll see the “Processing” lines appear before the loop — because .ToList() forces immediate execution.

🔹 Best Practices

✅ Use Deferred Execution when:

• The data may change before you consume it.
• You’re chaining multiple filters and projections.
• You want minimal upfront memory use.

✅ Use Immediate Execution when:

• You need a snapshot of the data at a given point.
• You’ll iterate multiple times (avoids re-querying).
• You’re working with databases — to prevent repeated trips to the server.

⚠️ Avoid pitfalls:

• Don’t modify a collection while it’s being enumerated — deferred queries can throw runtime errors.
• Be aware of when your query “goes live” – especially in loops or database calls.

🧩 Real-World Example – Combining Both Approaches

var products = new[]
{
    new { Name = "Laptop", Price = 1200 },
    new { Name = "Mouse", Price = 25 },
    new { Name = "Monitor", Price = 200 }
};

// Deferred filtering
var filtered = products.Where(p => p.Price > 50);

// Immediate projection
var snapshot = filtered.Select(p => new
{
    p.Name,
    Discount = p.Price * 0.9
}).ToList();

foreach (var s in snapshot)
    Console.WriteLine($"{s.Name} - £{s.Discount}");

Output:

Laptop - £1080
Monitor - £180

✅ Deferred filters apply lazily.
✅ Projection is captured immediately for safe reuse.

📚 Summary

✅ Best Practices

• Understand when LINQ queries are evaluated to avoid surprises.
• Use .ToList() intentionally — not by habit.
• Profile performance with large collections or database queries.
• When in doubt, print debug statements to see when the query actually runs.

🧪 Challenge Task

Create a LINQ query that filters all employees earning over £50,000 using deferred execution.
Then, call .ToList() to force immediate execution and print both results before and after adding a new employee to the list.

Expected output format:

Deferred: reflects new data
Immediate: stays unchanged

👨‍💻 Want More?

Learn advanced LINQ techniques in our Ocean Stack Advanced C# Course, including:

• Deferred vs Immediate Query Execution
• Query Optimization and Expression Trees
• LINQ to Objects vs LINQ to SQL
• Efficient use of projections and caching

Write smarter, more predictable, and high-performance C# code with full control over when and how your data is processed.