📝 Lesson 1.2: Extension Methods and Fluent APIs

What Is an Extension Method?

An extension method lets you call a static method as if it were an instance method on a type you didn't write. You've been using them all along: every LINQ operator (Where, Select, OrderBy) is an extension method on IEnumerable<T>.

The result reads naturally. Instead of StringHelper.Shout("hello"), you write:

string result = "hello".Shout();   // reads like a built-in string method

Writing Extension Methods

Three requirements: the method must live in a static class, be a static method, and have its first parameter marked this:

public static class StringExtensions
{
    // 'this string text' — extends the string type
    public static string Shout(this string text)
    {
        return text.ToUpper() + "!";
    }

    // Extension methods can take extra parameters too
    public static string Repeat(this string text, int times)
    {
        return string.Concat(Enumerable.Repeat(text, times));
    }
}

Now every string appears to have these methods:

Console.WriteLine("hello".Shout());       // HELLO!
Console.WriteLine("ab".Repeat(3));        // ababab
Console.WriteLine("hi".Shout().Repeat(2)); // HI!HI!  (chaining works!)

How the Compiler Sees It

Extension methods are pure compile-time sugar. When the compiler sees "hello".Shout(), it rewrites it into an ordinary static call:

// What you write:
"hello".Shout();

// What the compiler emits (equivalent):
StringExtensions.Shout("hello");

Rules and Limits

public static bool IsNullOrBlank(this string? text)
    => string.IsNullOrWhiteSpace(text);

string? name = null;
Console.WriteLine(name.IsNullOrBlank());   // True — no NullReferenceException

Extending Interfaces & Generics

The real power appears when you extend an interface or a generic type — one method then applies to every implementing or matching type. This is precisely how LINQ extends all of IEnumerable<T>:

public static class EnumerableExtensions
{
    // Works on ANY IEnumerable<T> — lists, arrays, LINQ results...
    public static bool None<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        return !source.Any(predicate);
    }
}

var numbers = new List<int> { 2, 4, 6 };
Console.WriteLine(numbers.None(n => n % 2 != 0));   // True — no odd numbers

You can also constrain the generic (Lesson 1.1) to unlock capabilities:

public static T MaxItem<T>(this IEnumerable<T> source) where T : IComparable<T>
{
    T max = source.First();
    foreach (T item in source)
    {
        if (item.CompareTo(max) > 0) max = item;
    }
    return max;
}

Fluent APIs

A fluent API is designed to be called as a readable chain of operations, where each method returns something you can keep calling on. LINQ is fluent; so are many builders and configuration APIs. The trick is simple: each method returns the object (or a new one) so the next call can continue.

public class QueryBuilder
{
    private readonly List<string> _clauses = new();

    public QueryBuilder From(string table)
    {
        _clauses.Add($"FROM {table}");
        return this;                    // return this → enables chaining
    }

    public QueryBuilder Where(string condition)
    {
        _clauses.Add($"WHERE {condition}");
        return this;
    }

    public QueryBuilder OrderBy(string column)
    {
        _clauses.Add($"ORDER BY {column}");
        return this;
    }

    public string Build() => string.Join(" ", _clauses);
}

The payoff is code that reads like a sentence:

string query = new QueryBuilder()
    .From("Users")
    .Where("Age > 18")
    .OrderBy("Name")
    .Build();

Console.WriteLine(query);
// FROM Users WHERE Age > 18 ORDER BY Name

Exercise & Quiz

Console.WriteLine("Hello, world".Truncate(5));   // Hello…

var errors = new Validator("hi")
    .NotEmpty()
    .MinLength(3)
    .MaxLength(20)
    .Errors();

foreach (var e in errors) Console.WriteLine(e);

public static class StringExtensions
{
    // TODO: Truncate(this string text, int maxLength)
}

public class Validator
{
    private readonly string _value;
    private readonly List<string> _errors = new();
    public Validator(string value) => _value = value;

    // TODO: NotEmpty(), MinLength(int), MaxLength(int) — each returns this
    // TODO: IReadOnlyList<string> Errors()
}

Console.WriteLine("Hello, world".Truncate(5));   // Hello…

var errors = new Validator("hi")
    .NotEmpty()
    .MinLength(3)
    .MaxLength(20)
    .Errors();

foreach (var e in errors) Console.WriteLine(e);
// Too short (min 3)

public static class StringExtensions
{
    public static string Truncate(this string text, int maxLength)
    {
        if (text.Length <= maxLength) return text;
        return text.Substring(0, maxLength) + "…";
    }
}

public class Validator
{
    private readonly string _value;
    private readonly List<string> _errors = new();
    public Validator(string value) => _value = value;

    public Validator NotEmpty()
    {
        if (string.IsNullOrEmpty(_value)) _errors.Add("Must not be empty");
        return this;
    }

    public Validator MinLength(int n)
    {
        if (_value.Length < n) _errors.Add($"Too short (min {n})");
        return this;
    }

    public Validator MaxLength(int n)
    {
        if (_value.Length > n) _errors.Add($"Too long (max {n})");
        return this;
    }

    public IReadOnlyList<string> Errors() => _errors;
}

Summary

📚 Additional Resources

• Extension methods — C# Programming Guide
• LINQ (built on extension methods)

🚀 What's Next?

You can extend types and design elegant APIs. Next, we look at how sequences can be produced lazily, one item at a time. In Lesson 1.3: Iterators and Lazy Sequences, you'll build your own IEnumerable with yield.