Extension methods and C# 14 extension members

using Rail.Text;

// A classic extension method: a static method whose first parameter carries this, called as if string had it.
var pnr = "4512398760";
Console.WriteLine($"pnr.Masked():               {pnr.Masked()}");
Console.WriteLine($"TextExtensions.Masked(pnr): {TextExtensions.Masked(pnr)}");

// The call is a static method call, so a null receiver arrives as an argument instead of throwing.
string? missing = null;
Console.WriteLine($"missing.IsBlank():          {missing.IsBlank()}");

namespace Rail.Text
{
    // Extension methods live in a static class that is not nested and not generic.
    public static class TextExtensions
    {
        // Every character but the last four becomes *, as on a ticket shared in a screenshot.
        public static string Masked(this string text) =>
            text.Length <= 4 ? text : new string('*', text.Length - 4) + text[^4..];

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

pnr.Masked():               ******8760
TextExtensions.Masked(pnr): ******8760
missing.IsBlank():          True

using Rail.Boarding;

// C# 14 extension blocks give sequences of boarding counts an instance property, a static method and an operator,
// next to a classic extension method. Callers use them as if IEnumerable<int> had declared them.
IEnumerable<int> morning = [5, 3, 8];
IEnumerable<int> evening = [2, 6, 1];

Console.WriteLine($"morning.Total: {morning.Total}, evening.Total: {evening.Total}");
Console.WriteLine($"IEnumerable<int>.Zeros(3): {string.Join(", ", IEnumerable<int>.Zeros(3))}");
Console.WriteLine($"morning + evening: {string.Join(", ", morning + evening)}");
Console.WriteLine($"morning.Busiest(): {morning.Busiest()}");

namespace Rail.Boarding
{
    public static class BoardingExtensions
    {
        // A receiver with a name: instance members, which read counts.
        extension(IEnumerable<int> counts)
        {
            public int Total => counts.Sum();
        }

        // A receiver type only: static members and operators of IEnumerable<int>.
        extension(IEnumerable<int>)
        {
            public static IEnumerable<int> Zeros(int stations) => Enumerable.Repeat(0, stations);

            // Station by station: the boardings of two trains added together.
            public static IEnumerable<int> operator +(IEnumerable<int> left, IEnumerable<int> right) =>
                left.Zip(right, (a, b) => a + b);
        }

        // A classic extension method in the same class: the two forms compile to the same kind of static method.
        public static int Busiest(this IEnumerable<int> counts) => counts.Max();
    }
}

morning.Total: 16, evening.Total: 9
IEnumerable<int>.Zeros(3): 0, 0, 0
morning + evening: 7, 9, 9
morning.Busiest(): 8

using Rail.Tickets;

// An extension never replaces a member that the type already has, and it reaches only what any other code can.
var ticket = new Ticket("4512398760", 2_150_00);
Console.WriteLine($"ticket.Describe():                 {ticket.Describe()}");
Console.WriteLine($"TicketExtensions.Describe(ticket): {TicketExtensions.Describe(ticket)}");
Console.WriteLine($"ticket.FareInRupees:               {ticket.FareInRupees}");

namespace Rail.Tickets
{
    public sealed class Ticket(string pnr, int farePaise)
    {
        public int FarePaise => farePaise;

        public string Describe() => $"ticket {pnr}";
    }

    public static class TicketExtensions
    {
        extension(Ticket ticket)
        {
            // Same name and parameters as Ticket.Describe, so ticket.Describe() never reaches it.
            public string Describe() => $"a ticket of {ticket.FarePaise} paise";

            // ticket.pnr would not compile here: an extension sees the public members, as any other code does.
            public decimal FareInRupees => ticket.FarePaise / 100m;
        }
    }
}

ticket.Describe():                 ticket 4512398760
TicketExtensions.Describe(ticket): a ticket of 215000 paise
ticket.FareInRupees:               2150

using System.Globalization;

// Practice: give DateOnly three C# 14 extension members. IsWeekend is true on Saturdays and Sundays. TaxYear names
// India's tax year, which runs from April to the following March, as "Tax Year 2026-27". DateOnly.Today(clock)
// returns the date in India, at UTC+05:30, at the clock's time. Run this file until all nine checks pass.
(string Check, Func<string> Run, string Expected)[] checks =
[
    ("a Saturday", () => new DateOnly(2026, 10, 17).IsWeekend.ToString(), "True"),
    ("a Monday", () => new DateOnly(2026, 10, 19).IsWeekend.ToString(), "False"),
    ("the first day of a tax year", () => new DateOnly(2026, 4, 1).TaxYear, "Tax Year 2026-27"),
    ("the last day of that year", () => new DateOnly(2027, 3, 31).TaxYear, "Tax Year 2026-27"),
    ("the day after", () => new DateOnly(2027, 4, 1).TaxYear, "Tax Year 2027-28"),
    ("a leap day", () => new DateOnly(2028, 2, 29).TaxYear, "Tax Year 2027-28"),
    ("a new century", () => new DateOnly(2099, 12, 1).TaxYear, "Tax Year 2099-00"),
    ("today from a clock", () => DateOnly.Today(Clock(2025, 11, 14, 6, 30)).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture), "2025-11-14"),
    ("today in India, not in UTC", () => DateOnly.Today(Clock(2027, 3, 31, 20, 0)).TaxYear, "Tax Year 2027-28"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, {got} instead of {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

// A clock that always gives this time in UTC.
static TimeProvider Clock(int year, int month, int day, int hour, int minute) =>
    new FixedClock(new DateTimeOffset(year, month, day, hour, minute, 0, TimeSpan.Zero));

sealed class FixedClock(DateTimeOffset utcNow) : TimeProvider
{
    public override DateTimeOffset GetUtcNow() => utcNow;
}

static class DateExtensions
{
    extension(DateOnly date)
    {
        public bool IsWeekend => throw new NotImplementedException();

        public string TaxYear => throw new NotImplementedException();
    }

    extension(DateOnly)
    {
        public static DateOnly Today(TimeProvider clock) => throw new NotImplementedException();
    }
}

a Saturday: FAIL, throws NotImplementedException instead of True
a Monday: FAIL, throws NotImplementedException instead of False
the first day of a tax year: FAIL, throws NotImplementedException instead of Tax Year 2026-27
the last day of that year: FAIL, throws NotImplementedException instead of Tax Year 2026-27
the day after: FAIL, throws NotImplementedException instead of Tax Year 2027-28
a leap day: FAIL, throws NotImplementedException instead of Tax Year 2027-28
a new century: FAIL, throws NotImplementedException instead of Tax Year 2099-00
today from a clock: FAIL, throws NotImplementedException instead of 2025-11-14
today in India, not in UTC: FAIL, throws NotImplementedException instead of Tax Year 2027-28
0 of 9 checks pass