Extension Members

public static class StringExtensions
{
    public static bool IsNullOrBlank(this string? value)
        => string.IsNullOrWhiteSpace(value);

    public static string Truncate(this string value, int maxLength, string suffix = "…")
    {
        ArgumentNullException.ThrowIfNull(value);
        return value.Length <= maxLength ? value : value[..maxLength] + suffix;
    }

    // Extension methods may be generic.
    public static IEnumerable<TSource> WhereNotNull<TSource>(
        this IEnumerable<TSource?> source) where TSource : class
    {
        foreach (TSource? item in source)
        {
            if (item is not null)
            {
                yield return item;
            }
        }
    }
}

public static class ExtensionDemo
{
    public static void Run()
    {
        Console.WriteLine("  ".IsNullOrBlank());                       // True
        Console.WriteLine("a long sentence".Truncate(6));              // a long…

        string?[] values = ["a", null, "b"];
        Console.WriteLine(string.Join(",", values.WhereNotNull()));     // a,b

        // Calling it as a plain static method is always legal, and is what the
        // compiler actually emits.
        Console.WriteLine(StringExtensions.Truncate("abcdef", 3));
    }
}

namespace Irurueta.Sample.Text;

public static class Casing
{
    public static string ToTitleCase(this string value)
        => CultureInfo.InvariantCulture.TextInfo.ToTitleCase(value.ToLowerInvariant());
}

using Irurueta.Sample.Text;      // without this, ToTitleCase does not exist

public static class DiscoveryDemo
{
    public static void Run() => Console.WriteLine("hello world".ToTitleCase());
}

public static class MiniLinq
{
    // This is essentially how System.Linq.Enumerable.Where is written.
    public static IEnumerable<TSource> Where<TSource>(
        this IEnumerable<TSource> source, Func<TSource, bool> predicate)
    {
        ArgumentNullException.ThrowIfNull(source);
        ArgumentNullException.ThrowIfNull(predicate);

        return Iterate();

        IEnumerable<TSource> Iterate()
        {
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    yield return item;
                }
            }
        }
    }

    public static IEnumerable<TResult> Select<TSource, TResult>(
        this IEnumerable<TSource> source, Func<TSource, TResult> selector)
    {
        foreach (TSource item in source)
        {
            yield return selector(item);
        }
    }
}

public interface IAuditable
{
    DateTimeOffset ModifiedAt { get; }
    string ModifiedBy { get; }
}

public static class AuditableExtensions
{
    // Behaviour shared by every implementer, with no base class and no
    // default interface member.
    public static bool ModifiedSince(this IAuditable auditable, DateTimeOffset when)
        => auditable.ModifiedAt > when;

    public static string Describe(this IAuditable auditable)
        => $"{auditable.ModifiedBy} at {auditable.ModifiedAt:u}";
}

public static class NullReceiver
{
    public static bool IsEmpty(this string? value) => value is null || value.Length == 0;

    public static void Demo()
    {
        string? nothing = null;

        Console.WriteLine(nothing.IsEmpty());     // True -- no NullReferenceException!

        // But an *instance* method on the same null would throw:
        // Console.WriteLine(nothing.Length);     // NullReferenceException
    }
}

public static class SequenceExtensions
{
    // The receiver is declared once for the whole block.
    extension<TSource>(IEnumerable<TSource> source)
    {
        // An extension PROPERTY -- impossible before C# 14.
        public bool IsEmpty => !source.Any();

        public int CountOrZero => source?.Count() ?? 0;

        // An extension method, in the same block.
        public IEnumerable<TSource> WhereNot(Func<TSource, bool> predicate)
            => source.Where(item => !predicate(item));
    }

    // A block for a specific closed type.
    extension(string text)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(text);

        public string Reversed
        {
            get
            {
                char[] characters = text.ToCharArray();
                Array.Reverse(characters);
                return new string(characters);
            }
        }

        public string Repeat(int times) => string.Concat(Enumerable.Repeat(text, times));
    }
}

public static class ExtensionBlockDemo
{
    public static void Run()
    {
        int[] numbers = [1, 2, 3, 4];

        Console.WriteLine(numbers.IsEmpty);                 // False -- a property!
        Console.WriteLine(string.Join(",", numbers.WhereNot(n => n % 2 == 0)));   // 1,3

        Console.WriteLine("  ".IsBlank);                    // True
        Console.WriteLine("abc".Reversed);                  // cba
        Console.WriteLine("ab".Repeat(3));                  // ababab
    }
}

public static class DictionaryIndexers
{
    extension<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> source)
        where TKey : notnull
    {
        // An extension indexer with a fallback, on an interface that has no setter.
        public TValue this[TKey key, TValue fallback]
            => source.TryGetValue(key, out TValue? value) ? value : fallback;
    }
}

// Used as:
//   IReadOnlyDictionary<string, int> counts = ...;
//   int hits = counts["missing", 0];

public sealed class Widget
{
    public string Describe() => "instance";
}

public static class WidgetExtensions
{
    public static string Describe(this Widget widget) => "extension";
    public static string DescribeVerbose(this Widget widget) => "extension only";
}

public static class ResolutionDemo
{
    public static void Run()
    {
        var widget = new Widget();

        Console.WriteLine(widget.Describe());          // instance -- the extension is shadowed
        Console.WriteLine(widget.DescribeVerbose());   // extension only

        // The extension is still reachable explicitly.
        Console.WriteLine(WidgetExtensions.Describe(widget));   // extension
    }
}