Why LINQ depends on extension methods in C Sharp (C#) - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an extension method for IEnumerable<int>.

C Sharp (C#)

public static class Extensions {
    public static int Sum(this IEnumerable<int> [1]) {
        int total = 0;
        foreach (var num in source) {
            total += num;
        }
        return total;
    }
}

Drag options to blanks, or click blank then click option'

Asource

Bitem

Clist

Dcollection

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name that is not descriptive or not valid as an identifier.

Forgetting the this keyword before the parameter.

The parameter name for the extension method must be a valid identifier. Here, source is commonly used to represent the input collection.

2fill in blank

medium

Complete the code to call the extension method on a list.

C Sharp (C#)

var numbers = new List<int> {1, 2, 3};
int total = numbers.[1]();

Drag options to blanks, or click blank then click option'

AAdd

BSort

CCount

DSum

Attempts:

3 left

💡 Hint

Common Mistakes

Using methods that do not return a sum like Add or Sort.

Forgetting that extension methods appear as if they are instance methods.

The Sum method is an extension method that calculates the total of all elements in the list.

3fill in blank

hard

Fix the error in the extension method declaration.

C Sharp (C#)

public static int CountItems([1]) {
    int count = 0;
    foreach (var item in source) {
        count++;
    }
    return count;
}

Drag options to blanks, or click blank then click option'

Athis IEnumerable<int> source

Bthis source

Csource

DIEnumerable<int> this source

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the this keyword.

Placing this after the type or parameter name incorrectly.

Extension methods must have the this keyword before the first parameter's type to indicate the method extends that type.

4fill in blank

hard

Fill both blanks to create an extension method that filters even numbers.

C Sharp (C#)

public static IEnumerable<int> [1](this IEnumerable<int> source) {
    foreach (var num in source) {
        if (num [2] 2 == 0) {
            yield return num;
        }
    }
}

Drag options to blanks, or click blank then click option'

AWhereEven

BSum

C%

DAdd

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names like Sum or Add.

Using wrong operators like + instead of modulus.

The method name WhereEven describes filtering even numbers. The modulus operator % checks divisibility.

5fill in blank

hard

Fill all three blanks to create an extension method that converts strings to uppercase and filters by length.

C Sharp (C#)

public static IEnumerable<string> [1](this IEnumerable<string> source, int minLength) {
    foreach (var str in source) {
        var upper = str.[2]();
        if (upper.Length [3] minLength) {
            yield return upper;
        }
    }
}

Drag options to blanks, or click blank then click option'

AFilterAndUpper

BToUpper

C>=

DToLower

Attempts:

3 left

💡 Hint

Common Mistakes

Using ToLower instead of ToUpper.

Using wrong comparison operators like <.

The method name FilterAndUpper describes the operation. ToUpper() converts strings to uppercase. The operator >= filters strings with length greater or equal to minLength.

Practice

1. Why does LINQ in C# rely on extension methods?

easy

A. To add query capabilities to existing types without modifying them

B. To create new classes for each query operation

C. To replace all existing methods in a class

D. To make the code run faster by compiling queries separately

Solution

1. Step 1: Understand LINQ's design goal

   LINQ aims to add query features to existing collections without changing their original code.

2. Step 2: Role of extension methods

   Extension methods allow adding new methods to existing types externally, enabling LINQ queries without modifying those types.

3. Final Answer:

   To add query capabilities to existing types without modifying them -> Option A

4. Quick Check:

   LINQ uses extension methods to extend types [OK]

Hint: Extension methods add features without changing original classes [OK]

Common Mistakes:

• Thinking LINQ creates new classes for queries
• Believing extension methods replace existing methods
• Assuming LINQ compiles queries separately for speed

2. Which of the following is the correct syntax to define an extension method used by LINQ?

easy

A. public int Sum(this IEnumerable<int> source) { ... }

B. public static int Sum(this IEnumerable<int> source) { ... }

C. public static int Sum(IEnumerable<int> source) { ... }

D. public int Sum(IEnumerable<int> source) { ... }

Solution

1. Step 1: Identify extension method syntax

   An extension method must be static and have the first parameter preceded by 'this' keyword.

2. Step 2: Check each option

   public static int Sum(this IEnumerable<int> source) { ... } is static and uses 'this' on the first parameter, correct for extension methods.

3. Final Answer:

   public static int Sum(this IEnumerable<int> source) { ... } -> Option B

4. Quick Check:

   Extension method = static + 'this' parameter [OK]

Hint: Extension methods are static with 'this' on first parameter [OK]

Common Mistakes:

• Omitting 'static' keyword
• Missing 'this' keyword on first parameter
• Making method non-static

3. What will be the output of this code snippet?

var numbers = new List<int> {1, 2, 3};
var result = numbers.Where(n => n > 1).Count();
Console.WriteLine(result);

medium

A. 3

B. 0

C. 1

D. 2

Solution

1. Step 1: Understand the Where clause

   It filters numbers greater than 1, so it keeps 2 and 3.

2. Step 2: Count the filtered elements

   There are 2 elements (2 and 3), so Count() returns 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Filtered count = 2 [OK]

Hint: Count filtered items after Where condition [OK]

Common Mistakes:

• Counting all elements without filtering
• Confusing > with >=
• Assuming Count returns sum

4. Identify the error in this LINQ extension method usage:

var list = new List<string> {"a", "bb", "ccc"};
var result = list.Where(s => s.Length > 1).ToList();
Console.WriteLine(result);

medium

A. Where method is not available on List<string>

B. Cannot call ToList() on IEnumerable

C. Console.WriteLine prints the type name, not the list contents

D. Missing using directive for System.Collections.Generic

Solution

1. Step 1: Check LINQ method usage

   Where and ToList() are valid extension methods on List<string>.

2. Step 2: Understand Console.WriteLine behavior

   Printing 'result' directly prints the type name, not the list elements.

3. Final Answer:

   Console.WriteLine prints the type name, not the list contents -> Option C

4. Quick Check:

   Printing list object shows type name [OK]

Hint: Use string.Join or loop to print list contents [OK]

Common Mistakes:

• Thinking ToList() is invalid
• Assuming Where is unavailable on List
• Forgetting to add using System.Linq

5. How can extension methods help LINQ support querying a custom collection class without modifying its source code?

hard

A. By defining static extension methods that accept the custom collection as 'this' parameter

B. By inheriting the custom collection from List<T> and overriding methods

C. By rewriting the custom collection to implement IQueryable interface

D. By adding query methods directly inside the custom collection class

Solution

1. Step 1: Understand extension methods role

   Extension methods add new methods externally without changing original class code.

2. Step 2: Apply to custom collection

   Defining static extension methods with 'this' parameter for the custom collection enables LINQ queries without modifying it.

3. Step 3: Evaluate other options

   Inheriting or rewriting requires source changes; adding methods inside class modifies it.

4. Final Answer:

   By defining static extension methods that accept the custom collection as 'this' parameter -> Option A

5. Quick Check:

   Extension methods extend without modifying class [OK]

Hint: Use static extension methods with 'this' on custom type [OK]

Common Mistakes:

• Thinking inheritance is required
• Assuming interface implementation is mandatory
• Trying to modify original class source