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.

Practice

1. What is a common performance consideration when using LINQ in C#?

easy

A. LINQ automatically caches all query results.

B. LINQ always executes queries immediately when defined.

C. LINQ queries are executed only when their results are requested.

D. LINQ does not support filtering collections.

Solution

1. Step 1: Understand LINQ query execution

   LINQ uses deferred execution, meaning queries run only when results are requested.

2. Step 2: Compare options with LINQ behavior

   The statement that LINQ queries are executed only when their results are requested correctly states deferred execution. The other options are incorrect because LINQ does not cache automatically, does not execute immediately when defined, and does support filtering collections.

3. Final Answer:

   LINQ queries are executed only when their results are requested. -> Option C

4. Quick Check:

   Deferred execution = LINQ queries are executed only when their results are requested. [OK]

Hint: Remember LINQ runs queries only when you ask for results [OK]

Common Mistakes:

• Assuming LINQ runs queries immediately when defined
• Thinking LINQ caches results automatically
• Believing LINQ cannot filter collections

2. Which of the following is the correct syntax to force immediate execution of a LINQ query in C#?

easy

A. var result = query.ToList();

B. var result = query.Where(x => x > 5);

C. var result = query.Select(x => x * 2);

D. var result = query.OrderBy(x => x);

Solution

1. Step 1: Identify methods that trigger immediate execution

   Methods like ToList() force LINQ to execute immediately and return a list.

2. Step 2: Analyze each option

   var result = query.ToList(); uses ToList(), which triggers execution. Where, Select, and OrderBy return queryable objects and do not execute immediately.

3. Final Answer:

   var result = query.ToList(); -> Option A

4. Quick Check:

   ToList() triggers execution = var result = query.ToList(); [OK]

Hint: Use ToList() to run LINQ query immediately [OK]

Common Mistakes:

• Using Where, Select, or OrderBy expecting immediate execution
• Not knowing ToList() triggers execution
• Confusing query definition with execution

3. Consider the following code:

var numbers = new List<int> {1, 2, 3, 4, 5};
var query = numbers.Where(n => n > 2);
var count1 = query.Count();
var count2 = query.Count();

What is the performance implication of this code?

medium

A. The query throws an exception on second Count() call.

B. The query is executed once and cached automatically.

C. The query results are stored in a list by default.

D. The query is executed twice, causing repeated filtering.

Solution

1. Step 1: Understand deferred execution and repeated calls

   Each call to Count() on a LINQ query triggers execution, so query runs twice here.

2. Step 2: Analyze caching behavior

   LINQ does not cache results automatically, so repeated calls cause repeated work.

3. Final Answer:

   The query is executed twice, causing repeated filtering. -> Option D

4. Quick Check:

   Repeated calls rerun query = The query is executed twice, causing repeated filtering. [OK]

Hint: Repeated calls rerun LINQ unless results are cached [OK]

Common Mistakes:

• Assuming LINQ caches results automatically
• Thinking Count() returns cached value on second call
• Believing query throws exceptions on multiple calls

4. Identify the performance issue in this code snippet:

var data = Enumerable.Range(1, 1000);
var filtered = data.Where(x => x % 2 == 0);
var list1 = filtered.ToList();
var list2 = filtered.ToList();

medium

A. The filtered query is executed twice, causing duplicate work.

B. ToList() does not execute the query.

C. The Where clause is ignored due to deferred execution.

D. Enumerable.Range creates an empty collection.

Solution

1. Step 1: Understand ToList() effect on query execution

   Each ToList() call executes the query fully, so filtered runs twice here.

2. Step 2: Identify repeated execution impact

   Repeated execution wastes resources; caching results in a variable avoids this.

3. Final Answer:

   The filtered query is executed twice, causing duplicate work. -> Option A

4. Quick Check:

   Multiple ToList() calls rerun query = The filtered query is executed twice, causing duplicate work. [OK]

Hint: Cache ToList() result to avoid running query twice [OK]

Common Mistakes:

• Thinking ToList() does not execute query
• Believing Where clause is ignored
• Assuming Enumerable.Range creates empty list

5. You have a LINQ query that filters and sorts a large collection multiple times in your code. What is the best way to improve performance?

hard

A. Rewrite the query each time to ensure fresh data is processed.

B. Store the filtered and sorted results in a list once, then reuse that list.

C. Avoid using ToList() to keep queries deferred for better performance.

D. Use multiple Where clauses instead of combining filters.

Solution

1. Step 1: Recognize repeated query execution cost

   Running the same LINQ query multiple times causes repeated filtering and sorting, which is expensive.

2. Step 2: Apply caching to improve performance

   Storing results in a list with ToList() once and reusing it avoids repeated work and improves speed.

3. Final Answer:

   Store the filtered and sorted results in a list once, then reuse that list. -> Option B

4. Quick Check:

   Caching query results = Store the filtered and sorted results in a list once, then reuse that list. [OK]

Hint: Cache query results with ToList() to reuse and save time [OK]

Common Mistakes:

• Re-running queries multiple times without caching
• Avoiding ToList() thinking deferred is always faster
• Splitting filters unnecessarily causing overhead