Fluent interface with extensions in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple fluent interface chain

What is the output of this C# code using a fluent interface?

C Sharp (C#)

public class Builder {
    private string text = "";
    public Builder AddHello() {
        text += "Hello";
        return this;
    }
    public Builder AddSpace() {
        text += " ";
        return this;
    }
    public Builder AddWorld() {
        text += "World";
        return this;
    }
    public override string ToString() => text;
}

var result = new Builder().AddHello().AddSpace().AddWorld().ToString();
System.Console.WriteLine(result);

A Hello World

B HelloWorld

C dlroW olleH

D Hello World

💡 Hint

Look at how spaces are added in the chain.

The methods AddHello, AddSpace, and AddWorld add strings and return the same object, allowing chaining. The space is added explicitly by AddSpace, so the output is "Hello World" exactly.

🧠 Conceptual

intermediate

Purpose of extension methods in fluent interfaces

Why are extension methods useful when building fluent interfaces in C#?

A They automatically generate UI elements for the fluent interface.

B They allow adding new chainable methods to existing classes without modifying them.

C They prevent the fluent interface from being used outside the assembly.

D They convert synchronous methods into asynchronous ones.

💡 Hint

Think about how you can add methods to a class you cannot change.

Extension methods let you add new methods to existing classes, enabling fluent chaining without changing the original class code.

🔧 Debug

advanced

Identify the error in this fluent interface extension method

What error will this code cause when compiling?

public static class BuilderExtensions {
    public static Builder AddExclamation(this Builder builder) {
        builder.ToString() += "!";
        return builder;
    }
}

A Cannot assign to method call result (ToString() returns string, which is immutable).

B Extension methods cannot return the original object.

C Missing semicolon after return statement.

D Builder class must be static to use extension methods.

💡 Hint

Consider what ToString() returns and if it can be assigned to.

ToString() returns a string value, which is immutable and cannot be assigned to. The code tries to append "!" to the result of ToString(), which is invalid.

📝 Syntax

advanced

Correct syntax for a fluent extension method

Which option shows the correct syntax for a fluent extension method that adds a period at the end of the Builder text?

A static Builder AddPeriod(Builder builder) { builder.text += "."; return builder; }

B public Builder AddPeriod(this Builder builder) { builder.text += "."; return builder; }

C public static Builder AddPeriod(this Builder builder) { builder.text += "."; return builder; }

D public static void AddPeriod(this Builder builder) { builder.text += "."; }

💡 Hint

Remember extension methods must be static and inside static classes.

Extension methods must be static methods inside static classes, with the first parameter preceded by 'this'. The method should return the builder to allow chaining.

🚀 Application

expert

Result of chaining multiple fluent extension methods

Given the following code, what is the final output?

public class Builder {
    private string text = "Start";
    public Builder Append(string s) {
        text += s;
        return this;
    }
    public override string ToString() => text;
}

public static class BuilderExtensions {
    public static Builder AddDash(this Builder b) => b.Append("-");
    public static Builder AddStar(this Builder b) => b.Append("*");
    public static Builder AddPlus(this Builder b) => b.Append("+");
}

var result = new Builder()
    .AddDash()
    .AddStar()
    .AddPlus()
    .AddDash()
    .ToString();
System.Console.WriteLine(result);

A Start-*+-

B Start-+*-

C Start-*+

D Start-*-+

💡 Hint

Follow the chain step by step, appending each symbol in order.

The Builder starts with "Start". Each extension method appends its symbol in the order called: AddDash adds '-', AddStar adds '*', AddPlus adds '+', then AddDash adds '-' again. So the final string is "Start-*+-".

Practice

1. What is the main purpose of a fluent interface in C#?

easy

A. To automatically generate user interfaces

B. To improve performance by using unsafe code

C. To enforce strict type checking at compile time

D. To allow chaining of method calls for clearer and simpler code

Solution

1. Step 1: Understand fluent interface concept

   A fluent interface is designed to let you chain method calls, making code easier to read and write.

2. Step 2: Compare options

   Only To allow chaining of method calls for clearer and simpler code describes chaining method calls clearly. Other options describe unrelated concepts.

3. Final Answer:

   To allow chaining of method calls for clearer and simpler code -> Option D

4. Quick Check:

   Fluent interface = chaining methods [OK]

Hint: Fluent means chaining methods for easy reading [OK]

Common Mistakes:

• Confusing fluent interface with performance optimization
• Thinking fluent interface auto-generates UI
• Mixing fluent interface with type checking

2. Which of the following is the correct syntax to define an extension method for a class Person that returns the same Person object to enable fluent chaining?

easy

A. public static void UpdateName(this Person p, string name) { p.Name = name; }

B. public Person UpdateName(Person p, string name) { p.Name = name; return p; }

C. public static Person UpdateName(this Person p, string name) { p.Name = name; return p; }

D. public static Person UpdateName(Person p, string name) { p.Name = name; return p; }

Solution

1. Step 1: Identify extension method syntax

   Extension methods must be static, inside static classes, and the first parameter uses this keyword to specify the extended type.

2. Step 2: Check return type for fluent chaining

   To enable chaining, the method must return the same object. public static Person UpdateName(this Person p, string name) { p.Name = name; return p; } returns Person and uses this Person p correctly.

3. Final Answer:

   public static Person UpdateName(this Person p, string name) { p.Name = name; return p; } -> Option C

4. Quick Check:

   Extension method + return self = public static Person UpdateName(this Person p, string name) { p.Name = name; return p; } [OK]

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

Common Mistakes:

• Omitting 'static' keyword on method
• Not using 'this' keyword on first parameter
• Returning void instead of the object for chaining

3. Given the following code, what is the output?

public class Person {
    public string Name { get; set; }
}

public static class PersonExtensions {
    public static Person SetName(this Person p, string name) {
        p.Name = name;
        return p;
    }
    public static Person PrintName(this Person p) {
        Console.WriteLine(p.Name);
        return p;
    }
}

var person = new Person();
person.SetName("Alice").PrintName();

medium

A. Alice

B. SetName

C. Compilation error

D. No output

Solution

1. Step 1: Understand method chaining

   The SetName extension sets the Name property and returns the same Person object. Then PrintName prints the Name and returns the object.

2. Step 2: Trace output

   Since SetName("Alice") sets Name to "Alice", PrintName() prints "Alice" to the console.

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   Chained methods print 'Alice' [OK]

Hint: Chained methods return object, so output is printed value [OK]

Common Mistakes:

• Expecting method names as output
• Thinking chaining causes compile error
• Assuming no output without explicit print

4. Identify the error in this extension method that aims to enable fluent chaining:

public static class StringExtensions {
    public static string AppendExclamation(string s) {
        s += "!";
        return s;
    }
}

medium

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

B. Method should return void for chaining

C. Cannot extend string type with extension methods

D. Method should be non-static

Solution

1. Step 1: Check extension method syntax

   Extension methods require the first parameter to have the this keyword to specify the type being extended.

2. Step 2: Identify missing 'this'

   The method parameter string s lacks this, so it is a normal static method, not an extension method.

3. Final Answer:

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

4. Quick Check:

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

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

Common Mistakes:

• Forgetting 'this' keyword
• Returning void instead of the object or string
• Thinking string cannot be extended

5. You want to create a fluent interface to build a SQL query string using extension methods on string. Which approach correctly supports chaining multiple calls like "SELECT *".AddWhere("Age > 30").AddOrderBy("Name")?

hard

A. Each extension method modifies the original string in place and returns void

B. Each extension method takes this string query, appends the clause, and returns the new string

C. Each extension method returns a new object type instead of string

D. Extension methods cannot be used on string for fluent interfaces

Solution

1. Step 1: Understand string immutability

   Strings in C# are immutable, so methods cannot modify the original string but must return a new string with changes.

2. Step 2: Fluent chaining requires returning updated string

   To chain calls, each method must return the updated string. Each extension method takes this string query, appends the clause, and returns the new string after appending clauses.

3. Final Answer:

   Each extension method takes this string query, appends the clause, and returns the new string -> Option B

4. Quick Check:

   Immutable string + return new string = Each extension method takes this string query, appends the clause, and returns the new string [OK]

Hint: Strings are immutable; return new string for chaining [OK]

Common Mistakes:

• Trying to modify string in place
• Returning void breaks chaining
• Assuming extension methods can't extend string