Extension methods for built-in types in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Extension methods for built-in types

Define static class

↓

Write static method with 'this' parameter

↓

Use method on built-in type instance

↓

Compiler treats call as static method call

↓

Method executes and returns result

Extension methods are static methods that look like instance methods on built-in types by using 'this' keyword in the first parameter.

Execution Sample

C Sharp (C#)

public static class StringExtensions {
    public static bool IsCapitalized(this string s) {
        return s.Length > 0 && char.IsUpper(s[0]);
    }
}

string word = "Hello";
bool result = word.IsCapitalized();

This code adds an extension method to string to check if the first letter is uppercase.

Execution Table

Step	Code Line	Action	Value/Result
1	Define static class StringExtensions	Prepare container for extension methods	Class ready
2	Define static method IsCapitalized(this string s)	Method ready to extend string	Method ready
3	Call word.IsCapitalized()	Compiler converts to IsCapitalized(word)	word = "Hello"
4	Check s.Length > 0	Evaluate length	5 (true)
5	Check char.IsUpper(s[0])	Check first char 'H'	true
6	Return true	Method returns	true

💡 Method returns true because 'Hello' starts with uppercase letter

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
word	"Hello"	"Hello"	"Hello"	"Hello"	"Hello"
s	N/A	"Hello"	"Hello"	"Hello"	"Hello"
result	N/A	N/A	N/A	N/A	true

Key Moments - 3 Insights

Why do we use 'this' keyword in the method parameter?

The 'this' keyword tells the compiler this method extends the type of that parameter, so it can be called like an instance method (see Step 2 and Step 3).

Is the extension method actually part of the built-in type?

No, the method is static in a separate class. The compiler just allows calling it like an instance method for convenience (Step 3).

What happens if the string is empty?

The method checks length > 0 first (Step 4). If false, it returns false without checking the first character.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'result' after Step 6?

A null

B false

C true

D Exception

💡 Hint

Check the 'Value/Result' column at Step 6 in the execution_table.

At which step does the method check if the first character is uppercase?

A Step 4

B Step 5

C Step 3

D Step 6

💡 Hint

Look at the 'Action' column describing char.IsUpper check in the execution_table.

If the string was empty, what would happen at Step 4?

A Length check returns false

B Length check returns true

C Method throws exception

D Method skips length check

💡 Hint

Refer to Step 4 where length is checked before accessing first character.

Concept Snapshot

Extension methods let you add new methods to existing types without changing them.
Define a static method in a static class.
Use 'this' before the first parameter to specify the type to extend.
Call the method like an instance method on that type.
Compiler converts it to a static method call behind the scenes.

Full Transcript

Extension methods in C# allow you to add new methods to built-in types like string without modifying their original code. You write a static method inside a static class, and the first parameter uses the 'this' keyword to specify which type you are extending. When you call this method on an instance of that type, the compiler treats it as a static method call but lets you write it as if it were an instance method. For example, the IsCapitalized method checks if the first letter of a string is uppercase. The execution steps show defining the method, calling it on a string, checking the string length, checking the first character, and returning the result. This makes your code cleaner and easier to read while extending functionality.