Extension Methods in C#

In C#, an extension method is a special kind of static method that allows you to add new methods to an existing type (class, struct or interface) without modifying its source code or creating a derived type. Extension methods are defined in a static class and are marked with the this keyword in their first parameter.

Syntax

public static class ClassName{
public static ReturnType MethodName(this TargetType obj, parameters){
// method body
}
}

Key Points

• Must be defined in a static class.
• Must be declared as a static method.
• The first parameter must use the this keyword to indicate the type being extended.
• They provide additional functionality without altering the original type.
• They are called like instance methods on the target type.

They are widely used to extend .NET types and interfaces, making code more readable and reusable. LINQ in C# is one of the most common examples of extension methods in action.

Example 1: Extension Method on Built-in Type

This example shows how to extend a built-in .NET type (string) with a custom method. We will add a WordCount method to count the number of words in a string.

Explanation:

• WordCount is defined as an extension method for the string type.
• It is called using sentence.WordCount() just like a built-in method.

Note: You can extend even sealed classes like string using extension methods, which cannot be inherited otherwise.

Example 2: Extension Method on User-defined Class

This example extends a user-defined class Student by adding a method PrintResult. The method evaluates whether the student has passed or failed, without modifying the original Student class.

• PrintResult extends the Student class without modifying it.
• It improves reusability and keeps the class definition cleaner.

Example 3: Extension Method on Interface

In this example, we extend an interface ILogger. By defining the LogError extension method, every class implementing ILogger automatically gains this additional functionality without needing to redefine it.

• LogError extends the ILogger interface.
• Any class implementing ILogger automatically gains this extra functionality.

NOTE: If an extension method is declared as public, then the type it extends (e.g., ILogger) must also be public. Otherwise, a compiler error occurs.

Benefits

• Add functionality without modifying original code.
• Can extend sealed classes (e.g., string, DateTime).
• Keep code clean and readable.
• Useful in scenarios like LINQ queries and utility functions.

Limitations

• Cannot override existing methods.
• Can lead to confusion if overused, especially with similar method names.
• Extension methods are static methods defined inside a static class, with the first parameter marked using the this keyword.