MSDN Documentation

C# Extension Methods

Extension methods enable you to "add" methods to existing types without actually modifying them. This is achieved by defining a static method in a static class. The first parameter of the extension method must be of the type that the method extends, and it must be preceded by the this keyword.

Defining an Extension Method

Consider a scenario where you want to add a method to the built-in string class to easily reverse it.

namespace MyExtensions
{
    public static class StringExtensions
    {
        public static string ReverseString(this string str)
        {
            char[] charArray = str.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }
    }
}

Using an Extension Method

Once defined, you can call the extension method on an instance of the type as if it were a member of that type. Make sure to import the namespace containing the extension method.

using System;
using MyExtensions; // Import the namespace

public class Program
{
    public static void Main(string[] args)
    {
        string message = "Hello, World!";
        string reversedMessage = message.ReverseString(); // Calling the extension method

        Console.WriteLine($"Original: {message}");
        Console.WriteLine($"Reversed: {reversedMessage}");
        // Output:
        // Original: Hello, World!
        // Reversed: !dlroW ,olleH
    }
}

Key Concepts and Benefits

• Extensibility: Add functionality to sealed classes or types you don't have access to the source code for.
• Readability: Can make code more fluent and easier to read by chaining method calls.
• Static Classes: Extension methods must be defined in a static class.
• this Keyword: The first parameter of an extension method must be of the type being extended and prefixed with this.
• Namespace Import: The namespace containing the extension method must be imported into the scope where you intend to use it.
• No Modification of Original Type: The original type's code is not actually changed.

Limitations

• Extension methods cannot be used to override instance methods of a type.
• An extension method can only be called if the type on which it is defined is accessible.
• If a type has an instance method that has the same name and signature as an extension method, the instance method will always be preferred.

When to Use Extension Methods

• To add utility methods to existing types that are commonly used.
• To create fluent interfaces or method chaining.
• When working with legacy code or third-party libraries where you cannot modify the source.

Example: Extension Methods for Collections

Extension methods are particularly useful for collections and LINQ.

using System.Collections.Generic;
using System.Linq;

namespace MyExtensions
{
    public static class CollectionExtensions
    {
        public static int CountItems<T>(this IEnumerable<T> collection)
        {
            return collection.Count();
        }

        public static bool IsEmpty<T>(this IEnumerable<T> collection)
        {
            return !collection.Any();
        }
    }
}

using System;
using System.Collections.Generic;
using MyExtensions;

public class DataProcessing
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        List<string> words = new List<string>();

        Console.WriteLine($"Number count: {numbers.CountItems()}");
        Console.WriteLine($"Is number list empty? {numbers.IsEmpty()}");

        Console.WriteLine($"Word count: {words.CountItems()}");
        Console.WriteLine($"Is word list empty? {words.IsEmpty()}");
    }
}