Custom LINQ extension methods in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a custom LINQ extension method

What is the output of this C# code using a custom LINQ extension method?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Linq;

public static class Extensions
{
    public static IEnumerable<int> DoubleEvenNumbers(this IEnumerable<int> source)
    {
        foreach (var num in source)
        {
            if (num % 2 == 0)
                yield return num * 2;
        }
    }
}

class Program
{
    static void Main()
    {
        var numbers = new List<int> {1, 2, 3, 4, 5};
        var result = numbers.DoubleEvenNumbers();
        foreach (var n in result)
            Console.Write(n + " ");
    }
}

A 4 8

B 1 3 5

C 2 4

D 1 2 3 4 5

💡 Hint

Look at which numbers are even and how they are transformed.

The method DoubleEvenNumbers yields only even numbers doubled. 2 becomes 4, 4 becomes 8.

🧠 Conceptual

intermediate

Purpose of 'this' keyword in extension methods

In C#, what does the this keyword before the first parameter in an extension method signify?

A It marks the method as static.

B It indicates the method is an extension method for the type of the parameter.

C It makes the method private.

D It means the method can only be called inside the class.

💡 Hint

Think about how extension methods add functionality to existing types.

The this keyword before the first parameter tells the compiler this method extends that type.

🔧 Debug

advanced

Identify the error in this custom LINQ extension method

What error will this code produce when compiled?

C Sharp (C#)

public static class Extensions
{
    public static IEnumerable<int> FilterOdds(this IEnumerable<int> source)
    {
        return source.Where(x => x % 2 == 1);
    }

    public static IEnumerable<int> FilterOdds(this List<int> source)
    {
        return source.Where(x => x % 2 == 1);
    }
}

A Compile-time error: Duplicate method name with same signature

B Compile-time error: Missing return statement

C Runtime error: StackOverflowException

D No error, compiles and runs fine

💡 Hint

Check method signatures and how overload resolution works for extension methods.

No error. The methods have different 'this' parameter types (IEnumerable<int> and List<int>), making them valid overloads. The compiler selects the most specific match at call sites.

📝 Syntax

advanced

Correct syntax for a custom LINQ extension method with multiple parameters

Which option shows the correct syntax for an extension method that filters strings by minimum length?

A public static IEnumerable<string> FilterByLength(IEnumerable<string> source, int minLength) { return source.Where(s => s.Length >= minLength); }

B public IEnumerable<string> FilterByLength(IEnumerable<string> source, int minLength) { return source.Where(s => s.Length >= minLength); }

C public static IEnumerable<string> FilterByLength(this IEnumerable<string> source, int minLength) { return source.Where(s => s.Length >= minLength); }

D public static IEnumerable<string> FilterByLength(this IEnumerable<string> source) { return source.Where(s => s.Length >= minLength); }

💡 Hint

Remember extension methods must be static and the first parameter uses this.

Option C correctly declares a static method with this on the first parameter and includes the extra parameter.

🚀 Application

expert

Result count after chaining custom LINQ extension methods

Given these two extension methods, what is the count of items in result?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Linq;

public static class Extensions
{
    public static IEnumerable<int> MultiplyBy(this IEnumerable<int> source, int factor)
    {
        foreach (var n in source)
            yield return n * factor;
    }

    public static IEnumerable<int> FilterGreaterThan(this IEnumerable<int> source, int threshold)
    {
        foreach (var n in source)
            if (n > threshold)
                yield return n;
    }
}

class Program
{
    static void Main()
    {
        var numbers = new List<int> {1, 2, 3, 4, 5};
        var result = numbers.MultiplyBy(3).FilterGreaterThan(10);
        Console.WriteLine(result.Count());
    }
}

A 2

B 0

C 3

D 1

💡 Hint

Multiply each number by 3, then count how many are greater than 10.

Numbers multiplied by 3: 3,6,9,12,15. Only 12 and 15 are > 10, so count is 2.

Practice

1. What is a key requirement for creating a custom LINQ extension method in C#?

easy

A. It must be a static method inside a static class with this on the first parameter.

B. It must be an instance method inside any class.

C. It must return void and take no parameters.

D. It must be declared inside the Main method.

Solution

1. Step 1: Understand extension method structure

   Extension methods must be static methods inside static classes.

2. Step 2: Identify the special parameter usage

   The first parameter must have the this keyword to specify the type it extends.

3. Final Answer:

   It must be a static method inside a static class with this on the first parameter. -> Option A

4. Quick Check:

   Extension method = static + static class + this param [OK]

Hint: Remember: static method + static class + this param [OK]

Common Mistakes:

• Making the method non-static
• Forgetting the static class container
• Omitting the 'this' keyword on the first parameter

2. Which of the following is the correct syntax to declare a custom LINQ extension method named IsEven for IEnumerable<int>?

easy

A. public static bool IsEven(this IEnumerable<int> source) { ... }

B. public bool IsEven(IEnumerable<int> source) { ... }

C. static bool IsEven(IEnumerable<int> source) { ... }

D. public static bool IsEven(IEnumerable<int> source) { ... }

Solution

1. Step 1: Check method modifiers and parameters

   The method must be public static and have this before the first parameter to be an extension method.

2. Step 2: Verify the parameter type and method signature

   public static bool IsEven(this IEnumerable<int> source) { ... } correctly uses this IEnumerable<int> source and is static and public.

3. Final Answer:

   public static bool IsEven(this IEnumerable<int> source) { ... } -> Option A

4. Quick Check:

   Extension method syntax = public static + this param [OK]

Hint: Look for 'public static' and 'this' on first parameter [OK]

Common Mistakes:

• Missing 'this' keyword on the first parameter
• Not making the method static
• Incorrect access modifier

3. Given this custom LINQ extension method, what will be the output?

public static IEnumerable<int> GetPositive(this IEnumerable<int> source) {
    foreach (var num in source) {
        if (num > 0) yield return num;
    }
}

var numbers = new List<int> { -1, 0, 3, 5, -2 };
var result = numbers.GetPositive().ToList();
Console.WriteLine(string.Join(",", result));

medium

A. -1,0,3,5,-2

B. 0,3,5

C. 3,5,-2

D. 3,5

Solution

1. Step 1: Understand the extension method logic

   The method yields only numbers greater than zero from the source list.

2. Step 2: Apply the method to the list

   From the list [-1, 0, 3, 5, -2], only 3 and 5 are greater than zero and yielded.

3. Final Answer:

   3,5 -> Option D

4. Quick Check:

   Filter positive numbers = 3,5 [OK]

Hint: Focus on the 'if (num > 0)' filter condition [OK]

Common Mistakes:

• Including zero as positive
• Returning all numbers without filtering
• Confusing yield return with return

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

public static IEnumerable<int> FilterEven(IEnumerable<int> source) {
    foreach (var num in source) {
        if (num % 2 == 0) yield return num;
    }
}

medium

A. Cannot use 'yield return' inside a foreach loop.

B. Method should return void instead of IEnumerable<int>.

C. Missing 'this' keyword on the first parameter to make it an extension method.

D. The modulo operator '%' is not valid in C#.

Solution

1. Step 1: Check extension method signature

   The method lacks the this keyword on the first parameter, so it is not an extension method.

2. Step 2: Verify other syntax elements

   Using yield return inside a foreach is valid, and '%' is a valid operator in C#.

3. Final Answer:

   Missing 'this' keyword on the first parameter to make it an extension method. -> Option C

4. Quick Check:

   Extension method requires 'this' on first parameter [OK]

Hint: Extension methods always need 'this' on first parameter [OK]

Common Mistakes:

• Forgetting 'this' keyword
• Thinking 'yield return' is invalid in loops
• Misunderstanding the modulo operator

5. You want to create a custom LINQ extension method ToDictionaryByLength that converts an IEnumerable<string> into a Dictionary<int, List<string>>, grouping strings by their length. Which implementation correctly achieves this?

hard

A. public static Dictionary ToDictionaryByLength(IEnumerable<string> source) {
return source.ToDictionary(s => s.Length, s => new List<string> { s });
}

B. public static Dictionary ToDictionaryByLength(this IEnumerable<string> source) {
return source.GroupBy(s => s.Length)
.ToDictionary(g => g.Key, g => g.ToList());
}

C. public static Dictionary ToDictionaryByLength(this IEnumerable<string> source) {
var dict = new Dictionary();
foreach (var s in source) {
dict[s.Length] = new List<string> { s };
}
return dict;
}

D. public static Dictionary ToDictionaryByLength(this IEnumerable<string> source) {
return source.ToDictionary(s => s.Length, s => s);
}

Solution

1. Step 1: Understand grouping by length

   We need to group strings by their length, so GroupBy with key s.Length is correct.

2. Step 2: Convert groups to dictionary

   Use ToDictionary with group key and list of strings as value.

3. Step 3: Check other options

   public static Dictionary ToDictionaryByLength(IEnumerable<string> source) { return source.ToDictionary(s => s.Length, s => new List<string> { s }); } does not group; it tries to create dictionary with duplicate keys causing error. public static Dictionary ToDictionaryByLength(this IEnumerable<string> source) { var dict = new Dictionary(); foreach (var s in source) { dict[s.Length] = new List<string> { s }; } return dict; } overwrites values instead of adding to list. public static Dictionary ToDictionaryByLength(this IEnumerable<string> source) { return source.ToDictionary(s => s.Length, s => s); } tries to map to string instead of list.

4. Final Answer:

   public static Dictionary<int, List<string>> ToDictionaryByLength(this IEnumerable<string> source) { return source.GroupBy(s => s.Length) .ToDictionary(g => g.Key, g => g.ToList()); } -> Option B

5. Quick Check:

   GroupBy + ToDictionary with list = correct grouping [OK]

Hint: Use GroupBy then ToDictionary with list conversion [OK]

Common Mistakes:

• Not grouping before ToDictionary
• Overwriting dictionary entries instead of adding to list
• Returning wrong value types in dictionary