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.