Extension Methods

Reviewed & published by Brayan K

What if you could add a method to string — a type you didn't write and can't change? Extension methods let you do exactly that. They're how LINQ bolts Where and Select onto every collection, and they're your tool for turning awkward helper calls into clean, readable, fluent code that reads like the method always belonged there.

Part of the free C# course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn

• Write an extension method with 'this'
• Add behaviour to types you don't own
• Pass extra parameters to extensions
• Build fluent, chainable helper APIs
• Understand how LINQ uses extensions
• When to use an extension vs a regular method

💡 Real-World Analogy

Think of a phone case with a built-in bottle opener. You didn't redesign the phone — the manufacturer can't and won't add a bottle opener — but the case snaps on and gives your phone a new ability that feels built-in. Extension methods snap new abilities onto existing types the same way: the original type is untouched, yet at the call site it looks like the method was always there.

1. Writing Your First Extension Method

Three rules: the method must be in a static class, the method must be static, and the first parameter must have the this modifier naming the type you're extending. That's it — now "hello".Shout() works, even though string has no Shout method. It's pure syntactic sugar for a static call.

using System;

// Extension methods live in a STATIC class and are STATIC methods.
// The 'this' keyword on the first parameter is the magic — it says
// "this method extends the string type".
static class StringExtensions
{
    public static string Shout(this string text) => text.ToUpper() + "!";
}

class Program
{
    static void Main()
    {
        string greeting = "hello";

        // Even though string has no Shout method, we can now call it
        // AS IF it were built in:
        Console.WriteLine(greeting.Shout());   // HELLO!

        // It's just syntactic sugar for:
        Console.WriteLine(StringExtensions.Shout(greeting)); // HELLO!
    }
}

// ✅ Expected output:
//    HELLO!
//    HELLO!

2. Extensions with Parameters

Anything after the this parameter is a normal argument. So age.IsBetween(18, 65) reads naturally while still being a plain static method underneath. You can extend any type — int, double, your own classes, even interfaces.

using System;

static class NumberExtensions
{
    // Extension methods can take extra parameters after 'this'.
    public static bool IsBetween(this int value, int low, int high)
        => value >= low && value <= high;

    // 'this' can extend any type — here, double:
    public static double RoundTo(this double value, int places)
        => Math.Round(value, places);
}

class Program
{
    static void Main()
    {
        int age = 25;
        Console.WriteLine(age.IsBetween(18, 65));   // True
        Console.WriteLine(age.IsBetween(30, 40));   // False

        double pi = 3.14159;
        Console.WriteLine(pi.RoundTo(2));            // 3.14
    }
}

// ✅ Expected output:
//    True
//    False
//    3.14

Your turn — write a Reversed() extension on string and call it.

using System;

static class StringExtras
{
    // 🎯 YOUR TURN — replace each ___ then press "Try it Yourself".

    // 1) An extension that reverses a string.
    //    Hint: new string(text.Reverse().ToArray())  needs System.Linq,
    //    but here we'll build it with a simple loop for clarity.
    public static string Reversed(this string ___)   // 👉  text
    {
        char[] chars = text.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}

class Program
{
    static void Main()
    {
        // 2) Call your new method on a string literal
        Console.WriteLine("stressed".___);    // 👉  Reversed()

        // ✅ Expected output:  desserts
    }
}

3. Extensions on Collections (the LINQ pattern)

Extension methods on IEnumerable<T> are exactly how LINQ works. You can write your own and chain them right alongside Where and Select. Here's a custom MedianOrZero() that slots straight into a LINQ pipeline.

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

static class CollectionExtensions
{
    // Extension methods are how LINQ itself works — Where, Select, etc.
    // are all extension methods on IEnumerable<T>. Here's a custom one:
    public static double MedianOrZero(this IEnumerable<int> source)
    {
        var sorted = source.OrderBy(x => x).ToList();
        if (sorted.Count == 0) return 0;
        int mid = sorted.Count / 2;
        return sorted.Count % 2 == 1
            ? sorted[mid]
            : (sorted[mid - 1] + sorted[mid]) / 2.0;
    }
}

class Program
{
    static void Main()
    {
        var numbers = new List<int> { 7, 1, 5, 3, 9 };

        // Chain our custom extension right alongside built-in LINQ:
        var result = numbers.Where(n => n > 2).MedianOrZero();
        Console.WriteLine(result);   // 7   (from {7,5,3,9}, sorted {3,5,7,9}, median 6)

        Console.WriteLine(new List<int>().MedianOrZero()); // 0  (empty, safe)
    }
}

// ✅ Expected output:
//    6
//    0

🧩 Reorder Challenge

These lines define and use a Doubled() extension, but they're out of order. Arrange them so the program compiles and prints 14.

A.     public static int Doubled(this int n) => n * 2;
B. static class IntExtensions {
C.     int result = 7.Doubled();
D. }
E.     Console.WriteLine(result);

B. static class IntExtensions {
A.     public static int Doubled(this int n) => n * 2;
D. }
// ...inside Main:
C.     int result = 7.Doubled();
E.     Console.WriteLine(result);

// Output:  14

The static class wrapping the static this-method must be declared before the call site can use 7.Doubled().

🧠 Quick Recall

1. What does this print?

static class E { public static int Sq(this int n) => n * n; }
Console.WriteLine(6.Sq());

36 — 6.Sq() calls the extension, returning 6 * 6.

2. What does this print?

static class E { public static string Twice(this string s) => s + s; }
Console.WriteLine("ab".Twice());

abab — the extension concatenates the string with itself.

3. True or false: an extension method can override a real instance method of the same name.

False — instance methods always win; the extension is only used when no instance method matches.

Putting It Together: a Validation Toolkit

Real teams keep call-sites readable by grouping little helpers as extensions. Here's a tiny string-validation toolkit you'd genuinely use.

using System;

// A small, readable validation toolkit built from extension methods.
// This is how real codebases keep call-sites clean.
static class ValidationExtensions
{
    public static bool IsValidEmail(this string s)
        => !string.IsNullOrWhiteSpace(s) && s.Contains('@') && s.Contains('.');

    public static string OrDefault(this string? s, string fallback)
        => string.IsNullOrWhiteSpace(s) ? fallback : s;

    public static string Truncate(this string s, int max)
        => s.Length <= max ? s : s.Substring(0, max) + "...";
}

class Program
{
    static void Main()
    {
        Console.WriteLine("user@site.com".IsValidEmail()); // True
        Console.WriteLine("not-an-email".IsValidEmail());  // False

        string? name = null;
        Console.WriteLine(name.OrDefault("Anonymous"));    // Anonymous

        Console.WriteLine("This is a long description".Truncate(10)); // This is a ...
    }
}

// ✅ Expected output:
//    True
//    False
//    Anonymous
//    This is a ...

Pro Tips

• 💡 Use extensions to add behaviour to sealed or third-party types you can't modify — that's their killer use case.
• 💡 Keep extensions focused and discoverable — group them in a clearly named static class like StringExtensions.
• 💡 Handle null gracefully: extensions can be called on a null reference (it just passes null as this), so guard for it.
• 💡 Don't reach for extensions when you own the type — add a real method instead; extensions are for types you can't change.

Common Errors (and the fix)

• "CS1109: Extension methods must be defined in a non-generic static class": wrap the method in a static class.
• "CS1106: Extension method must be static": the method itself must be static, not just the class.
• Method not found at the call site: you forgot the using for the namespace that contains the static class.
• Expecting it to mutate the original: extensions on value types or strings can't change the original — return a new value instead.

Mini-Challenge: a WordCount Extension

Add a WordCount() method to string — the kind of small helper you'll reuse forever. Declare the static class, write the method, and call it.

using System;

class Program
{
    static void Main()
    {
        // 🎯 MINI-CHALLENGE: a WordCount extension
        // 1. Above Program, declare:  static class TextExtensions { ... }
        // 2. Add:  public static int WordCount(this string text)
        //    that returns how many words are in the string.
        //    Hint: text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length
        // 3. Call "the quick brown fox".WordCount() and print it.
        //
        // ✅ Example output:
        //    4

        // your code here
    }
}

🎉 Lesson Complete

• ✅ Extension methods are static methods with this on the first parameter
• ✅ They add behaviour to types you don't own, like string
• ✅ Extra parameters come after this
• ✅ LINQ itself is built from extension methods on IEnumerable<T>
• ✅ Instance methods always win over extensions of the same name

Practice quiz

Continue this course

• Previous: Tuples & Deconstruction
• Next: DateTime — Work with dates, times, spans and formatting
• Quick reference: C# cheat sheet

Frequently asked questions

Why does the first parameter use 'this'?

The 'this' modifier on the first parameter is what turns an ordinary static method into an extension method. It tells the compiler 'this method can be called as if it were an instance method of that parameter's type'. value.Method() is just sugar for Class.Method(value).

Do extension methods modify the original type?

No. They don't change the type's source code or add real members to it — they're resolved by the compiler at call sites. That's why you can extend types you don't own, like string, int, or classes from a NuGet package.

Where do extension methods have to live?

Inside a static, non-nested class, and the method itself must be static with 'this' on its first parameter. To use it, the namespace containing that static class must be in scope (via a using directive).

What happens if an extension method has the same name as a real method?

Instance methods always win. If the type already has a matching method, the compiler calls that and ignores your extension. Extension methods only fill gaps where no instance method matches.

Is LINQ built from extension methods?

Yes — Where, Select, OrderBy, Sum and the rest are all extension methods on IEnumerable<T> defined in System.Linq. That's why you add 'using System.Linq;' to unlock them, and why your custom extensions chain seamlessly alongside them.