C# Extension Methods Explained — How, Why and When to Use Them

using System;
using System.Linq;

// The class MUST be static and non-nested
public static class StringExtensions
{
    // The 'this' keyword on the first parameter is what makes this an extension method.
    // 'source' will receive whatever string you call .WordCount() on.
    public static int WordCount(this string source)
    {
        // Guard against null — the caller might chain this on a nullable reference
        if (string.IsNullOrWhiteSpace(source))
            return 0;

        // Split on any whitespace and filter out empty entries caused by multiple spaces
        return source.Split(new char[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }

    // A second extension to show they stack naturally on the same type
    public static string ToTitleCase(this string source)
    {
        if (string.IsNullOrWhiteSpace(source))
            return source;

        // Split, capitalise the first letter of each word, rejoin
        return string.Join(' ',
            source.Split(' ')
                  .Select(word => word.Length > 0
                      ? char.ToUpper(word[0]) + word.Substring(1).ToLower()
                      : word));
    }
}

// ---- Program entry point ----
class Program
{
    static void Main()
    {
        string article = "the quick brown fox jumps over the lazy dog";

        // Looks like an instance method call — but it's our static method in disguise
        int count = article.WordCount();
        Console.WriteLine($"Word count: {count}");

        // Chaining works naturally because each extension returns a value
        string titleCased = article.ToTitleCase();
        Console.WriteLine($"Title case: {titleCased}");

        // Works with null safely because we guard inside the method
        string nullString = null;
        Console.WriteLine($"Null word count: {nullString.WordCount()}");
    }
}

using System;
using System.Collections.Generic;

public static class DateTimeExtensions
{
    // Replaces repeated DayOfWeek comparisons scattered across the codebase
    public static bool IsWeekend(this DateTime date)
        => date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;

    // Returns the next occurrence of a given day — useful for scheduling features
    public static DateTime NextOccurrenceOf(this DateTime startDate, DayOfWeek targetDay)
    {\n        // Move forward one day at a time until we hit the target\n        int daysUntilTarget = ((int)targetDay - (int)startDate.DayOfWeek + 7) % 7;\n\n        // If today is already that day, jump to next week's occurrence\n        if (daysUntilTarget == 0) daysUntilTarget = 7;\n\n        return startDate.AddDays(daysUntilTarget);\n    }\n\n    // Formats a DateTime as a human-friendly relative string — \"3 days ago\", \"just now\", etc.\n    public static string ToRelativeTime(this DateTime pastDate)\n    {\n        TimeSpan elapsed = DateTime.UtcNow - pastDate.ToUniversalTime();\n\n        if (elapsed.TotalSeconds < 60)  return \"just now\";\n        if (elapsed.TotalMinutes < 60)  return $\"{(int)elapsed.TotalMinutes} minutes ago\";\n        if (elapsed.TotalHours < 24)    return $\"{(int)elapsed.TotalHours} hours ago\";\n        if (elapsed.TotalDays < 7)      return $\"{(int)elapsed.TotalDays} days ago\";\n        if (elapsed.TotalDays < 30)     return $\"{(int)(elapsed.TotalDays / 7)} weeks ago\";\n\n        return pastDate.ToString(\"MMM d, yyyy\");\n    }\n}\n\npublic static class EnumerableExtensions\n{\n    // Fluent pipeline pattern — processes items in batches, common in bulk API calls\n    public static IEnumerable<IEnumerable<T>> InBatchesOf<T>(this IEnumerable<T> source, int batchSize)\n    {\n        if (batchSize <= 0)\n            throw new ArgumentOutOfRangeException(nameof(batchSize), \"Batch size must be at least 1\");\n\n        var batch = new List<T>(batchSize);\n\n        foreach (T item in source)\n        {\n            batch.Add(item);\n\n            // Yield the batch when it's full, then start a fresh one\n            if (batch.Count == batchSize)\n            {\n                yield return batch;\n                batch = new List<T>(batchSize);\n            }
        }

        // Don't forget the final partial batch
        if (batch.Count > 0)
            yield return batch;
    }
}

class Program
{
    static void Main()
    {
        DateTime today = DateTime.Today;
        Console.WriteLine($"Is today a weekend? {today.IsWeekend()}");
        Console.WriteLine($"Next Monday: {today.NextOccurrenceOf(DayOfWeek.Monday):dddd, MMM d}");

        DateTime threeHoursAgo = DateTime.UtcNow.AddHours(-3);
        Console.WriteLine($"Posted: {threeHoursAgo.ToRelativeTime()}");

        // Fluent batch processing pipeline — reads like plain English
        var productIds = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        foreach (var batch in productIds.InBatchesOf(3))
        {
            Console.WriteLine($"Processing batch: [{string.Join(", ", batch)}]");
        }
    }
}

using System;
using System.Text.RegularExpressions;

// GOOD use of extension methods: pure, stateless validation predicates
// These make business logic read like a requirements document
public static class ValidationExtensions
{\n    private static readonly Regex EmailPattern =\n        new Regex(@\"^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$\", RegexOptions.Compiled);\n\n    private static readonly Regex PhonePattern =\n        new Regex(@\"^\\+?[1-9]\\d{7,14}$\", RegexOptions.Compiled);\n\n    public static bool IsValidEmail(this string candidate)\n        => !string.IsNullOrWhiteSpace(candidate) && EmailPattern.IsMatch(candidate);\n\n    public static bool IsValidPhoneNumber(this string candidate)\n        => !string.IsNullOrWhiteSpace(candidate) && PhonePattern.IsMatch(candidate);\n\n    // Guard method pattern — throws a descriptive exception for invalid inputs\n    // Useful at the boundary of a method to replace boilerplate null checks\n    public static T ThrowIfNull<T>(this T value, string parameterName) where T : class\n    {\n        if (value is null)\n            throw new ArgumentNullException(parameterName,\n                $\"{parameterName} cannot be null. Provide a valid {typeof(T).Name} instance.\");\n        return value; // Returns the value so you can chain: var safe = input.ThrowIfNull(nameof(input));\n    }\n\n    // Clamp a numeric value to a range — stateless, pure, belongs on the type\n    public static int Clamp(this int value, int minimum, int maximum)\n    {\n        if (minimum > maximum)\n            throw new ArgumentException($\"minimum ({minimum}) must be <= maximum ({maximum})\");\n\n        return Math.Max(minimum, Math.Min(maximum, value));\n    }\n}\n\n// ---- Simulated registration form validation ----\nclass Program\n{\n    static void Main()\n    {\n        string userEmail = \"alice@example.com\";\n        string badEmail  = \"not-an-email\";\n        string phone     = \"+447911123456\";\n\n        // Business logic now reads like requirements: IF email IS valid email...\n        Console.WriteLine($\"'{userEmail}' is valid email: {userEmail.IsValidEmail()}\");\n        Console.WriteLine($\"'{badEmail}' is valid email:  {badEmail.IsValidEmail()}\");\n        Console.WriteLine($\"'{phone}' is valid phone: {phone.IsValidPhoneNumber()}\");\n\n        // Guard pattern in action\n        try\n        {\n            string config = null;\n            config.ThrowIfNull(nameof(config)); // Throws immediately with a useful message\n        }\n        catch (ArgumentNullException ex)\n        {\n            Console.WriteLine($\"Caught: {ex.Message}\");\n        }\n\n        // Clamp: user input slider value must stay between 1 and 100\n        int rawSliderValue = 142;\n        int safeValue = rawSliderValue.Clamp(1, 100);\n        Console.WriteLine($\"Clamped {rawSliderValue} to range [1,100]: {safeValue}\");\n    }\n}",
        "output": "'alice@example.com' is valid email: True\n'not-an-email' is valid email:  False\n'+447911123456' is valid phone: True\nCaught: config cannot be null. Provide a valid String instance. (Parameter 'config')\nClamped 142 to range [1,100]: 100"
      }

using System;
using System.Collections.Generic;

public static class GenericExtensions
{
    // Throws if null; returns the value for chaining. Works on any reference type.
    public static T ThrowIfNull<T>(this T value, string name) where T : class
    {\n        if (value is null)\n            throw new ArgumentNullException(name);\n        return value;\n    }

    // Checks if a collection is sorted in ascending order.
    public static bool IsSorted<T>(this IEnumerable<T> source) where T : IComparable<T>
    {
        using var enumerator = source.GetEnumerator();
        if (!enumerator.MoveNext()) return true; // empty is sorted
        T previous = enumerator.Current;
        while (enumerator.MoveNext())
        {
            if (enumerator.Current.CompareTo(previous) < 0)
                return false;
            previous = enumerator.Current;
        }
        return true;
    }

    // Shuffles a list in-place using Fisher-Yates.
    public static void Shuffle<T>(this IList<T> list, Random rng = null)
    {\n        rng ??= Random.Shared;\n        for (int i = list.Count - 1; i > 0; i--)\n        {\n            int j = rng.Next(i + 1);\n            (list[i], list[j]) = (list[j], list[i]);\n        }
    }
}

class Program
{
    static void Main()
    {
        // Works on any reference type
        string text = "hello";
        text.ThrowIfNull(nameof(text)); // no-op

        // Works on any IEnumerable<T> with IComparable<T> items
        int[] numbers = { 1, 2, 3, 4 };
        Console.WriteLine($"Is sorted: {numbers.IsSorted()}"); // True

        int[] mixed = { 3, 1, 2 };
        Console.WriteLine($"Is sorted: {mixed.IsSorted()}"); // False

        // Shuffle any IList<T>
        var list = new List<int> { 1, 2, 3, 4, 5 };
        list.Shuffle();
        Console.WriteLine($"Shuffled: {string.Join(", ", list)}");
    }
}

using System;
using System.Collections.Generic;

// BAD: Stateful extension — uses static cache
public static class BadExtensions
{
    private static readonly Dictionary<string, bool> _cache = new();

    public static bool IsBlacklisted(this string url)
    {
        if (_cache.TryGetValue(url, out bool result))
            return result;
        // ... check external service? That's even worse!
        return false;
    }
}

// GOOD: Stateless extension
public static class GoodExtensions
{
    private static readonly HashSet<string> KnownBlacklist = new(StringComparer.OrdinalIgnoreCase)
    {
        "malware.com", "phishing.net"
    };

    public static bool IsBlacklisted(this string url)
    {
        // Pure function — no side effects
        return KnownBlacklist.Contains(url);
    }
}

// BAD: Overly broad — extends object
public static class ObjectExtensions
{
    public static string Describe(this object obj) => obj?.ToString() ?? "null";
}
// This method appears on EVERY type in the project, including value types, strings, interfaces.
// Avoid unless you have a very good reason.

// io.thecodeforge -- csharp tutorial
// This compiles but which method runs?

namespace Sales {
    public static class SalesExtensions {
        public static decimal CalculateBonus(this Employee emp) 
            => emp.Salary * 0.1m;
    }
}

namespace Hr {
    public static class HrExtensions {
        public static decimal CalculateBonus(this Employee emp) 
            => emp.Salary * 0.15m;
    }
}

namespace Company {
    using Sales;
    using Hr; // Both in scope!

    public class Payroll {
        public void Process(Employee joe) {
            var bonus = joe.CalculateBonus(); // CS0121: ambiguous
            // Fix: Sales.SalesExtensions.CalculateBonus(joe);
        }
    }
}

// io.thecodeforge -- csharp tutorial
// Batch processing without pulling everything into memory

public static class EnumerableExtensions {
    public static IEnumerable<IEnumerable<T>> Chunk<T>(
        this IEnumerable<T> source, int size)
    {
        if (size <= 0) throw new ArgumentException("Size must be > 0");
        var bucket = new List<T>(size);
        foreach (var item in source) {
            bucket.Add(item);
            if (bucket.Count == size) {
                yield return bucket;
                bucket = new List<T>(size);
            }
        }
        if (bucket.Count > 0) yield return bucket;
    }
}

// Usage
var batches = allOrders.Chunk(100);
foreach (var batch in batches) {
    dbContext.BulkInsert(batch);
}

// io.thecodeforge -- csharp tutorial
// Three patterns that prevent production bugs

public static class GuardExtensions {
    // Pattern 1: Fluent validation
    public static string ThrowIfNullOrWhiteSpace(
        this string value, string paramName)
        => string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentNullException(paramName)
            : value;

    // Pattern 2: Null-safe collections
    public static IEnumerable<T> OrEmptyIfNull<T>(this IEnumerable<T>? source)
        => source ?? Enumerable.Empty<T>();

    // Pattern 3: Typed config binding
    public static T GetRequired<T>(
        this IConfiguration config, string sectionName) where T : new()
    {
        var section = config.GetSection(sectionName);
        var instance = new T();
        section.Bind(instance);
        return instance;
    }
}

// Usage
var customers = await api.GetCustomersAsync();
var safeCustomers = customers.OrEmptyIfNull();
foreach (var c in safeCustomers) { // never null
    Process(c);
}

// io.thecodeforge — csharp tutorial

using System.Collections;

public static class ArrayListExtensions
{
    public static bool TryAdd(this ArrayList list, object item)
    {
        if (list.IsReadOnly)
            return false;
        list.Add(item);
        return true;
    }
}

var items = ArrayList.FixedSize(new ArrayList { 1, 2, 3 });
bool added = items.TryAdd(4);
Console.WriteLine(added); // False
Console.WriteLine(items.IsReadOnly); // True

// io.thecodeforge — csharp tutorial

using System.Threading;

public static class LoopExtensions
{
    public static void RunUntilCancelled(this Action work, CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            work();
            Thread.Sleep(100);
        }
    }
}

var cts = new CancellationTokenSource();
cts.CancelAfter(500);
int count = 0;
(() => count++).RunUntilCancelled(cts.Token);
Console.WriteLine(count); // ~5 iterations

// io.thecodeforge — csharp tutorial
namespace Presentation.Customers;

public static class CustomerExtensions
{
    public static string ToDisplayName(this Customer c) =>
        $"{c.FirstName} {c.LastName}";
}

namespace Data.Export;

public static class CustomerCsvExtensions
{
    public static string ToCsvLine(this Customer c) =>
        $"{c.Id},{c.Email},{c.LastPurchaseDate}";
}

// io.thecodeforge — csharp tutorial
public static class StringExtensions
{
    // Good: clearly extends string, stateless
    public static bool IsNullOrWhiteSpace(this string s) =>
        string.IsNullOrWhiteSpace(s);
}

// Bad: extending own type
public class Order
{
    public decimal Total { get; set; }
}

public static class BadExtensions
{
    // Should be instance method Order.CalculateTax()
    public static decimal CalculateTax(this Order o) => o.Total * 0.1m;
}

// io.thecodeforge — csharp tutorial
var result = customer
    .ToDomainModel()     // layer extension
    .CalculateDiscount(0.1m)  // domain logic
    .ToInvoiceFormat();  // layer extension

// Reads like a pipeline, not a utility mess