Fluent interface with extensions in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Fluent interface with extensions

Create base object

↓

Call first method

↓

Return same object

↓

Call extension method

↓

Return same object

↓

Chain more calls or finish

Start with an object, call methods that return the same object, including extension methods, allowing chaining calls fluently.

Execution Sample

C Sharp (C#)

public class Builder {
  private string _text = "";
  public Builder Add(string s) { _text += s; return this; }
  public override string ToString() => _text;
}

public static class BuilderExtensions {
  public static Builder AddExclamation(this Builder b) { b.Add("!"); return b; }
}

var b = new Builder();
b.Add("Hi").AddExclamation();

This code shows a class with a method returning itself and an extension method also returning the same object, enabling chaining.

Execution Table

Step	Action	Object State	Return Value	Chain Continues
1	Create Builder object	Empty Builder	Builder instance	Yes
2	Call Add("Hi")	Builder with "Hi"	Same Builder instance	Yes
3	Call AddExclamation() extension	Builder with "Hi!"	Same Builder instance	Yes
4	Chain ends or continue	Builder with "Hi!"	Same Builder instance	No

💡 Chain ends after last method call; object has accumulated changes.

Variable Tracker

Variable	Start	After Add("Hi")	After AddExclamation()	Final
b	Empty Builder	Builder with "Hi"	Builder with "Hi!"	Builder with "Hi!"

Key Moments - 3 Insights

Why does Add() return 'this' instead of void?

Returning 'this' allows chaining calls on the same object, as shown in execution_table steps 2 and 3.

How can an extension method be part of the chain?

Extension methods take the object as 'this' parameter and return it, enabling chaining like in step 3.

What happens if a method in the chain returns a different type?

The chain breaks because the next method may not exist on the returned type; here all return the same Builder type.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of object 'b' after step 3?

A Builder with "Hi!"

B Empty Builder

C Builder with "Hi"

D null

💡 Hint

Check 'Object State' column at step 3 in execution_table.

At which step does the extension method get called?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for 'Call AddExclamation() extension' in the Action column.

If Add() returned void instead of 'this', what would happen to the chain?

A Chain would still work normally

B Chain would break after Add() call

C Extension method would be called first

D Object state would reset

💡 Hint

Refer to key_moments about why methods return 'this' for chaining.

Concept Snapshot

Fluent interface uses methods returning the same object to chain calls.
Extension methods can be added to extend fluent chains.
Each method returns 'this' (the object) to continue chaining.
If a method returns a different type or void, chaining breaks.
This style improves readability and expressiveness.

Full Transcript

This example shows how a fluent interface works in C# using a class with methods returning the same object. The Builder class has an Add method that returns 'this' so calls can chain. An extension method AddExclamation is defined to add an exclamation mark and also returns the same object. The execution table traces creating the object, calling Add, then the extension method, showing the object state and return values. Key moments clarify why returning 'this' is important and how extension methods fit in. The visual quiz tests understanding of object state after steps and the effect of method return types on chaining. The concept snapshot summarizes fluent interfaces and extension methods for chaining calls.