LINQ performance considerations in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

LINQ Deferred Execution Output

What will be the output of this C# code snippet using LINQ deferred execution?

C Sharp (C#)

var numbers = new List<int> {1, 2, 3, 4};
var query = numbers.Where(n => n > 2);
numbers.Add(5);
foreach (var num in query) {
    Console.Write(num + " ");
}

A 3 4 5

B 1 2 3 4 5

C 3 4

D 2 3 4 5

💡 Hint

Remember that LINQ queries are not executed until you iterate over them.

LINQ uses deferred execution, so the query runs when iterated. Since 5 was added before iteration, it is included.

🧠 Conceptual

intermediate

LINQ Query Performance Impact

Which of the following statements about LINQ query performance is TRUE?

A LINQ queries that use deferred execution can reduce memory usage by processing items one at a time.

B Using multiple LINQ queries on the same data source always improves performance.

C LINQ queries always execute immediately when declared.

D LINQ queries cannot be optimized by the compiler or runtime.

💡 Hint

Think about how deferred execution affects memory and processing.

Deferred execution means LINQ processes elements as needed, which can reduce memory usage compared to immediate execution.

❓ Predict Output

advanced

LINQ Query Performance with Multiple Enumerations

What is the output of this C# code and what performance issue does it illustrate?

C Sharp (C#)

var data = Enumerable.Range(1, 3);
var query = data.Select(x => {
    Console.WriteLine($"Processing {x}");
    return x * 2;
});
var list1 = query.ToList();
var list2 = query.ToList();
Console.WriteLine(list1.Sum());

A

Processing 1
Processing 2
Processing 3
Processing 1
Processing 2
Processing 3
6

B

Processing 1
Processing 2
Processing 3
Processing 1
Processing 2
Processing 3
12

C 12

D

Processing 1
Processing 2
Processing 3
12

💡 Hint

Consider how many times the query is enumerated and what side effects happen during enumeration.

The query is enumerated twice because ToList() is called twice, causing the processing code to run twice.

🔧 Debug

advanced

Identifying LINQ Performance Bottleneck

This code runs slower than expected. What is the main cause of the performance issue?

C Sharp (C#)

var largeList = Enumerable.Range(1, 1000000).ToList();
var result = largeList.Where(x => x % 2 == 0).OrderByDescending(x => x).Take(10).ToList();

A Using ToList() at the end causes the query to run multiple times.

B Filtering with Where is slow because it enumerates the entire list twice.

C Ordering the entire filtered list before taking 10 items causes unnecessary processing.

D Take(10) should be placed before OrderByDescending to improve performance.

💡 Hint

Think about how OrderByDescending works on large collections.

Ordering the entire filtered list sorts all matching items, which is expensive. Better to limit items before sorting if possible.

🧠 Conceptual

expert

Best Practice for LINQ Performance Optimization

Which approach is the best practice to improve LINQ query performance on large datasets?

A Avoid using LINQ and write all loops manually for better performance.

B Always convert queries to lists immediately to avoid deferred execution overhead.

C Use nested LINQ queries extensively to reduce code size and improve speed.

D Use deferred execution and avoid multiple enumerations by caching results when needed.

💡 Hint

Consider how deferred execution and multiple enumerations affect performance.

Deferred execution is efficient but repeated enumeration can hurt performance; caching results avoids this.