How to use extension methods in C#

These methods enhance code readability and enable the extension of classes or interfaces without the need for subclassing or recompiling.

Introduced in C# 3.0, extension methods are commonly used in .NET, such as with LINQ standard query operators, which provide additional query capabilities to `System.Collections.IEnumerable` and `System.Collections.Generic.IEnumerable<T>`.

An extension method is a special static method that lets you add functionality to an existing type without access to its source code. It includes the "this" reference as its first parameter and can be applied to any type, including value types. You can add as many extension methods as needed to a type.

Define an extension method in C#

Extension methods in C# allow you to add functionality to existing types without modifying or inheriting from them, and without recompiling the original code.

To define an extension method, follow these steps:

1. Create a static class to hold the method.
2. Define a static method inside this class with the "this" keyword in the first parameter.
3. The "this" reference designates the type being extended.

Here’s an example using a custom class Car and an extension method that calculates the car’s age based on its manufacturing year:

public class Car
{
    public int ManufacturingYear { get; set; }
    public string Make { get; set; }
}

public static class CarExtensions
{
    public static int GetCarAge(this Car car)
    {
        return DateTime.Now.Year - car.ManufacturingYear;
    }
}

In this example, the Car class represents a car with a ManufacturingYear. The extension method GetCarAge calculates how old the car is by subtracting the manufacturing year from the current year.

You can invoke the extension method like this:

Car myCar = new Car { ManufacturingYear = 2015, Make = "Toyota" };
Console.WriteLine($"The car's age is: { myCar.GetCarAge() } years.");

Using extension methods to extend existing types

Extension methods are not limited to user-defined types, you can also extend built-in types like DateTime.

For example, let’s add an extension method to DateTime that checks if the date is a weekend:

public static class DateTimeExtensions
{
    public static bool IsWeekend(this DateTime date)
    {
        return date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;
    }
}

You can now check if a DateTime object represents a weekend date:

DateTime today = DateTime.Now;
Console.WriteLine($"Is today a weekend? {today.IsWeekend()}");

If today is a Saturday or Sunday, the method will return true.

You can also extend collections.

For instance, let's add an extension method to the List<T> class to calculate the sum of all elements in a list of integers:

public static class ListExtensions
{
    public static int SumList(this List<int> list)
    {
        return list.Sum();
    }
}

You can use this extension method like this:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
Console.WriteLine($"The sum of the list is: {numbers.SumList()}");

This will output the sum of the integers in the list, which is 15.

Overloading an Extension Method in C#

In C#, extension methods can also be overloaded like regular methods.

For instance, let’s consider overloading the ToUpperCase method of the string class to optionally add an exclamation mark at the end of the string. This overloaded method will take a bool parameter that specifies whether to append the exclamation mark.

public static class StringExtensions
{
    public static string ToUpperCase(this string str, bool addExclamationMark)
    {
        string result = str.ToUpper();
        if (addExclamationMark)
        {
            result += "!";
        }
        return result;
    }
}

You can use this extension method as follows:

string message = "hello";
string result = message.ToUpperCase(true);
Console.WriteLine(result);

If the addExclamationMark parameter is true, the output will be "HELLO!". If false is passed, it will simply return "HELLO" without the exclamation mark.

Extending Interfaces in C#

Extension methods can also be applied to interfaces, allowing you to add new functionality to them.

For example, let’s extend an interface IVehicle with an extension method that calculates the maximum speed based on the vehicle type.

public interface IVehicle
{
    void StartEngine();
}

public class Car : IVehicle
{
    public void StartEngine()
    {
        Console.WriteLine("Car engine started.");
    }
}

Now, let’s create an extension method for the IVehicle interface to calculate the maximum speed:

public static class VehicleExtensions
{
    public static int GetMaxSpeed(this IVehicle vehicle)
    {
        if (vehicle is Car)
        {
            return 120; // Example for a car
        }
        return 0; // Default for other types
    }
}

Now you can use the GetMaxSpeed method with any IVehicle object:

IVehicle myCar = new Car();
Console.WriteLine($"Max speed of my car is: {myCar.GetMaxSpeed()} km/h");

This will output the maximum speed for the Car object, which in this case is 120 km/h.

Working with extension methods in C#

Extension methods in C# have the following key points:

1. They must be static methods.
2. The first parameter must be a reference to the type being extended.
3. They cannot access private members or modify the private state of a class.
4. They can extend interfaces or classes but cannot override existing methods.
5. While they make code more expressive and fluent, they should be used sparingly to avoid making the code harder to understand. Extension methods are not meant to reduce the amount of code unnecessarily.