Extension method syntax in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Extension method syntax

Define static class

↓

Write static method with 'this' parameter

↓

Use method as if it belongs to the type

↓

Call extension method on instance

↓

Execute method body

↓

Return result or perform action

Extension methods are static methods in static classes that use 'this' on the first parameter to add new methods to existing types, allowing calls as if they were instance methods.

Execution Sample

C Sharp (C#)

public static class StringExtensions {
    public static int WordCount(this string str) {
        return str.Split(' ').Length;
    }
}

string text = "Hello world";
int count = text.WordCount();

This code adds a WordCount method to string, counting words by splitting on spaces.

Execution Table

Step	Action	Evaluation	Result
1	Define static class StringExtensions	Class created	Ready to hold extension methods
2	Define static method WordCount with 'this string str'	Method ready to extend string	Can be called on string instances
3	Create string variable text = "Hello world"	Variable holds "Hello world"	text = "Hello world"
4	Call text.WordCount()	Calls WordCount with str = "Hello world"	Executes method body
5	Inside WordCount: str.Split(' ')	Splits "Hello world" into ["Hello", "world"]	Array length = 2
6	Return length 2	Method returns 2	count = 2
7	Use count variable	count holds 2	Output or further use possible
8	End	No more steps	Execution complete

💡 Method call completes and returns word count 2, execution ends.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	Final
text	null	"Hello world"	"Hello world"	"Hello world"	"Hello world"
str (in WordCount)	N/A	N/A	"Hello world"	"Hello world"	N/A
count	undefined	undefined	undefined	2	2

Key Moments - 3 Insights

Why does the WordCount method have 'this string str' as its first parameter?

The 'this' keyword before the first parameter tells C# this is an extension method for the string type, allowing calls like text.WordCount() as shown in step 4.

Is the WordCount method called like a normal static method?

No, even though WordCount is static, it is called like an instance method on a string variable (step 4), thanks to the extension method syntax.

What happens inside the WordCount method when called?

The method splits the string by spaces (step 5), counts the parts, and returns the count (step 6), which is then stored in count.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'count' after step 6?

A 1

B 2

C 0

D Undefined

💡 Hint

Check the 'Result' column at step 6 where the method returns the length 2.

At which step is the extension method WordCount actually called on the string instance?

A Step 5

B Step 2

C Step 4

D Step 3

💡 Hint

Look at the 'Action' column to find when text.WordCount() is invoked.

If we remove 'this' from the first parameter of WordCount, what changes in the execution?

A The method can no longer be called as text.WordCount()

B The method still works the same way

C The method becomes an instance method

D The method will cause a runtime error

💡 Hint

Refer to the key moment explaining the role of 'this' in extension methods.

Concept Snapshot

Extension methods add new methods to existing types.
They are static methods in static classes.
The first parameter uses 'this' to specify the type extended.
Called like instance methods on the extended type.
Useful to add functionality without changing original code.

Full Transcript

Extension methods in C# let you add new methods to existing types without changing their code. You write a static method inside a static class, and the first parameter has the 'this' keyword before the type you want to extend. This lets you call the method as if it belongs to that type. For example, a WordCount method added to string can be called like text.WordCount(). The execution starts by defining the static class and method, then creating a string variable. When calling the extension method, the string instance is passed as the first argument. Inside the method, the string is split by spaces and the number of words is returned. The result is stored in a variable. This way, extension methods provide a neat way to add features to types you don't own.