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)
    {
        // Move forward one day at a time until we hit the target
        int daysUntilTarget = ((int)targetDay - (int)startDate.DayOfWeek + 7) % 7;

        // If today is already that day, jump to next week's occurrence
        if (daysUntilTarget == 0) daysUntilTarget = 7;

        return startDate.AddDays(daysUntilTarget);
    }

    // Formats a DateTime as a human-friendly relative string — "3 days ago", "just now", etc.
    public static string ToRelativeTime(this DateTime pastDate)
    {
        TimeSpan elapsed = DateTime.UtcNow - pastDate.ToUniversalTime();

        if (elapsed.TotalSeconds < 60)  return "just now";
        if (elapsed.TotalMinutes < 60)  return $"{(int)elapsed.TotalMinutes} minutes ago";
        if (elapsed.TotalHours < 24)    return $"{(int)elapsed.TotalHours} hours ago";
        if (elapsed.TotalDays < 7)      return $"{(int)elapsed.TotalDays} days ago";
        if (elapsed.TotalDays < 30)     return $"{(int)(elapsed.TotalDays / 7)} weeks ago";

        return pastDate.ToString("MMM d, yyyy");
    }
}

public static class EnumerableExtensions
{
    // Fluent pipeline pattern — processes items in batches, common in bulk API calls
    public static IEnumerable<IEnumerable<T>> InBatchesOf<T>(this IEnumerable<T> source, int batchSize)
    {
        if (batchSize <= 0)
            throw new ArgumentOutOfRangeException(nameof(batchSize), "Batch size must be at least 1");

        var batch = new List<T>(batchSize);

        foreach (T item in source)
        {
            batch.Add(item);

            // Yield the batch when it's full, then start a fresh one
            if (batch.Count == batchSize)
            {
                yield return batch;
                batch = new List<T>(batchSize);
            }
        }

        // 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
{
    private static readonly Regex EmailPattern =
        new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.Compiled);

    private static readonly Regex PhonePattern =
        new Regex(@"^\+?[1-9]\d{7,14}$", RegexOptions.Compiled);

    public static bool IsValidEmail(this string candidate)
        => !string.IsNullOrWhiteSpace(candidate) && EmailPattern.IsMatch(candidate);

    public static bool IsValidPhoneNumber(this string candidate)
        => !string.IsNullOrWhiteSpace(candidate) && PhonePattern.IsMatch(candidate);

    // Guard method pattern — throws a descriptive exception for invalid inputs
    // Useful at the boundary of a method to replace boilerplate null checks
    public static T ThrowIfNull<T>(this T value, string parameterName) where T : class
    {
        if (value is null)
            throw new ArgumentNullException(parameterName,
                $"{parameterName} cannot be null. Provide a valid {typeof(T).Name} instance.");
        return value; // Returns the value so you can chain: var safe = input.ThrowIfNull(nameof(input));
    }

    // Clamp a numeric value to a range — stateless, pure, belongs on the type
    public static int Clamp(this int value, int minimum, int maximum)
    {
        if (minimum > maximum)
            throw new ArgumentException($"minimum ({minimum}) must be <= maximum ({maximum})");

        return Math.Max(minimum, Math.Min(maximum, value));
    }
}

// ---- Simulated registration form validation ----
class Program
{
    static void Main()
    {
        string userEmail = "alice@example.com";
        string badEmail  = "not-an-email";
        string phone     = "+447911123456";

        // Business logic now reads like requirements: IF email IS valid email...
        Console.WriteLine($"'{userEmail}' is valid email: {userEmail.IsValidEmail()}");
        Console.WriteLine($"'{badEmail}' is valid email:  {badEmail.IsValidEmail()}");
        Console.WriteLine($"'{phone}' is valid phone: {phone.IsValidPhoneNumber()}");

        // Guard pattern in action
        try
        {
            string config = null;
            config.ThrowIfNull(nameof(config)); // Throws immediately with a useful message
        }
        catch (ArgumentNullException ex)
        {
            Console.WriteLine($"Caught: {ex.Message}");
        }

        // Clamp: user input slider value must stay between 1 and 100
        int rawSliderValue = 142;
        int safeValue = rawSliderValue.Clamp(1, 100);
        Console.WriteLine($"Clamped {rawSliderValue} to range [1,100]: {safeValue}");
    }
}