How do I actually "add" a method to a class I didn't write?

It feels like magic, but you aren't actually modifying the original source code of the class. Instead, you're creating a static method in a static class, and you're telling the C# compiler to "pretend" it's an instance method. The secret sauce is the this keyword in the first parameter of your method.

Let's say you're building a blog and you constantly need to turn titles into URL-friendly "slugs" (like turning "Hello World!" into "hello-world"). Rather than passing a string into a helper method every time, you can just extend string itself:

public static class StringExtensions
{
    public static string ToSlug(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return string.Empty;

        return text.ToLower()
                   .Replace(" ", "-")
                   .TrimStart('-')
                   .TrimEnd('-');
    }
}

Now, anywhere in your project, you can just call myTitle.ToSlug(). I love this because it keeps the calling code clean. You don't have to go hunting for a StringHelper class; the method just shows up in IntelliSense as if it were always there.

Isn't this just a fancy wrapper for a utility class?

Technically, yes. Under the hood, the compiler is just converting your call to a standard static method call. But from a developer experience perspective, it's a huge win. When you use a utility class, you have to remember the name of the class (Is it FileUtils? FileHelper? SystemUtils?). With extension methods, the functionality is discovered through the object you're already working with.

I've seen a lot of devs overdo this, though. Don't extend object or string with a hundred niche methods that only apply to one specific corner of your app. If a method is only useful in one specific service, just keep it in that service. Extension methods are best for general-purpose logic that feels like it should have been part of the original type.

Can I do this with generic collections too?

Absolutely. In fact, this is exactly how LINQ (Language Integrated Query) works. Every single LINQ method like .Where() or .Select() is just an extension method on IEnumerable<T>. You can do the same thing for your own custom logic.

For example, I often find myself needing to grab a random element from a list. C# doesn't have a built-in .Random() method for lists, so I just write my own:

public static class CollectionExtensions
{
    private static readonly Random _random = new Random();

    public static T GetRandomElement<T>(this IList<T> list)
    {
        if (list == null || list.Count == 0)
            throw new InvalidOperationException("The list is empty.");

        int index = _random.Next(list.Count);
        return list[index];
    }
}

Now, whether you have a List<string> or a List<User>, you can just call myList.GetRandomElement(). It's clean, reusable, and typesafe.

📋 Practical Task

Exercise: Building a Currency Formatter Extension

In many financial applications, you need to format decimal values consistently. Your task is to create an extension method for the decimal type that formats a number as a currency string with a specific prefix and two decimal places, but only if the value is positive. If the value is negative, it should return the string "N/A".

Requirements:

• Create a static class named CurrencyExtensions.
• Implement a method called ToPriceString that takes a decimal as the target (using the this keyword).
• The method should take a second parameter: string currencySymbol (e.g., "$", "€").
• If the value is 12.5, and the symbol is "$", it should return "$12.50".
• If the value is -1.0, it should return "N/A".

Test your code with these cases:

decimal price1 = 49.99m;
Console.WriteLine(price1.ToPriceString("$")); // Expected: $49.99

decimal price2 = -5.00m;
Console.WriteLine(price2.ToPriceString("$")); // Expected: N/A

decimal price3 = 10m;
Console.WriteLine(price3.ToPriceString("£")); // Expected: £10.00