Static members, static classes and shared state

// A static field belongs to the type: one value that every Ticket shares. An instance field belongs to each ticket.
var first = new Ticket("Asha Rao");
var second = new Ticket("Ravi Iyer");
var third = new Ticket("Meena Das");

Console.WriteLine($"{first.Passenger} has ticket {first.Number}");
Console.WriteLine($"{third.Passenger} has ticket {third.Number}");
Console.WriteLine($"tickets issued: {Ticket.Issued}");
Console.WriteLine($"fare for 3 adults and 2 children: {Fares.Total(adults: 3, children: 2)} paise");

class Ticket
{
    // One counter for the whole program, shared by every Ticket object.
    private static int s_issued;

    public Ticket(string passenger)
    {
        s_issued++;
        Passenger = passenger;
        Number = 1000 + s_issued;
    }

    // Instance members: each ticket has its own.
    public string Passenger { get; }

    public int Number { get; }

    // A static property: read through the type, never through a ticket.
    public static int Issued => s_issued;
}

// A static class holds only static members and can never be created with new.
static class Fares
{
    public const long AdultPaise = 45_000;

    public static long Total(int adults, int children) => (adults * AdultPaise) + (children * AdultPaise / 2);
}

Asha Rao has ticket 1001
Meena Das has ticket 1003
tickets issued: 3
fare for 3 adults and 2 children: 180000 paise

// A static constructor runs once, just before its type is first used. Watch the numbered lines.
Console.WriteLine("1. the program starts");
Console.WriteLine("2. Tax has not been used yet");
Console.WriteLine($"5. Tax.Percent is {Tax.Percent}");
Console.WriteLine($"6. tax on 1000 rupees is {Tax.On(1000m)}, and nothing ran again");

static class Tax
{
    public static readonly int Percent = Show("3. the static field initializer runs", 18);

    static Tax()
    {
        Console.WriteLine("4. the static constructor runs");
    }

    public static decimal On(decimal amount) => amount * Percent / 100;

    private static int Show(string line, int value)
    {
        Console.WriteLine(line);
        return value;
    }
}

1. the program starts
2. Tax has not been used yet
3. the static field initializer runs
4. the static constructor runs
5. Tax.Percent is 18
6. tax on 1000 rupees is 180, and nothing ran again

// Two tests of a checkout that numbers its orders, run in both orders: first with a static counter, then with a
// counter object that each test creates for itself.
Console.WriteLine("static counter");
Run("first-order test, then two-orders test", FirstOrderStatic, TwoOrdersStatic);
StaticOrderNumbers.ResetForTests();
Run("two-orders test, then first-order test", TwoOrdersStatic, FirstOrderStatic);

Console.WriteLine("counter object passed in");
Run("first-order test, then two-orders test", FirstOrder, TwoOrders);
Run("two-orders test, then first-order test", TwoOrders, FirstOrder);

static void Run(string label, params Func<string>[] tests)
{
    Console.WriteLine($"  {label}");
    foreach (var test in tests)
    {
        Console.WriteLine($"    {test()}");
    }
}

static string FirstOrderStatic() => FirstOrderIs1001(new StaticCheckout().PlaceOrder);

static string TwoOrdersStatic() => TwoOrdersAre1001And1002(new StaticCheckout().PlaceOrder);

// Each test creates the counter its checkout uses.
static string FirstOrder() => FirstOrderIs1001(new Checkout(new OrderNumbers(1001)).PlaceOrder);

static string TwoOrders() => TwoOrdersAre1001And1002(new Checkout(new OrderNumbers(1001)).PlaceOrder);

static string FirstOrderIs1001(Func<string> placeOrder)
{
    string got = placeOrder();
    return got == "ORD-1001" ? "first order is ORD-1001: pass" : $"first order is ORD-1001: FAIL, got {got}";
}

static string TwoOrdersAre1001And1002(Func<string> placeOrder)
{
    string got = $"{placeOrder()} and {placeOrder()}";
    string name = "two orders are ORD-1001 and ORD-1002";
    return got == "ORD-1001 and ORD-1002" ? $"{name}: pass" : $"{name}: FAIL, got {got}";
}

// The static design: one counter for the whole process.
static class StaticOrderNumbers
{
    private static int s_next = 1001;

    public static int Next() => s_next++;

    public static void ResetForTests() => s_next = 1001;
}

class StaticCheckout
{
    public string PlaceOrder() => $"ORD-{StaticOrderNumbers.Next()}";
}

// The instance design: whoever creates a checkout decides which counter it uses.
class OrderNumbers
{
    private int _next;

    public OrderNumbers(int first) => _next = first;

    public int Next() => _next++;
}

class Checkout
{
    private readonly OrderNumbers _numbers;

    public Checkout(OrderNumbers numbers) => _numbers = numbers;

    public string PlaceOrder() => $"ORD-{_numbers.Next()}";
}

static counter
  first-order test, then two-orders test
    first order is ORD-1001: pass
    two orders are ORD-1001 and ORD-1002: FAIL, got ORD-1002 and ORD-1003
  two-orders test, then first-order test
    two orders are ORD-1001 and ORD-1002: pass
    first order is ORD-1001: FAIL, got ORD-1003
counter object passed in
  first-order test, then two-orders test
    first order is ORD-1001: pass
    two orders are ORD-1001 and ORD-1002: pass
  two-orders test, then first-order test
    two orders are ORD-1001 and ORD-1002: pass
    first order is ORD-1001: pass

// Practice: the old IdGenerator was a static class with one static counter that OrderService and InvoiceService both
// called, so tests depended on each other. Write it as a class that each service is given, then run this file until
// all six checks pass. Numbers start at the value passed in, which must be 1 or more.
(string Check, Func<string> Run, string Expected)[] checks =
[
    ("the first id", () => new IdGenerator(start: 1).Next().ToString(), "1"),
    ("three ids in a row", () => Three(new IdGenerator(start: 41)), "41,42,43"),
    ("two generators are independent", TwoGenerators, "1,2,1"),
    ("two services share one generator", SharedGenerator, "ORD-1,INV-2,ORD-3"),
    ("each service with its own", OwnGenerators, "ORD-1,INV-1"),
    ("a start of 0", () => new IdGenerator(start: 0).Next().ToString(), "throws ArgumentOutOfRangeException"),
];

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;

static string Three(IdGenerator ids) => $"{ids.Next()},{ids.Next()},{ids.Next()}";

static string TwoGenerators()
{
    var a = new IdGenerator(start: 1);
    var b = new IdGenerator(start: 1);
    return $"{a.Next()},{a.Next()},{b.Next()}";
}

static string SharedGenerator()
{
    var ids = new IdGenerator(start: 1);
    var orders = new OrderService(ids);
    var invoices = new InvoiceService(ids);
    return $"{orders.Create()},{invoices.Create()},{orders.Create()}";
}

static string OwnGenerators()
{
    var orders = new OrderService(new IdGenerator(start: 1));
    var invoices = new InvoiceService(new IdGenerator(start: 1));
    return $"{orders.Create()},{invoices.Create()}";
}

class IdGenerator
{
    public IdGenerator(int start) => throw new NotImplementedException();

    public int Next() => throw new NotImplementedException();
}

class OrderService
{
    public OrderService(IdGenerator ids) => throw new NotImplementedException();

    // An order id such as ORD-1.
    public string Create() => throw new NotImplementedException();
}

class InvoiceService
{
    public InvoiceService(IdGenerator ids) => throw new NotImplementedException();

    // An invoice id such as INV-2.
    public string Create() => throw new NotImplementedException();
}

the first id: FAIL, throws NotImplementedException instead of 1
three ids in a row: FAIL, throws NotImplementedException instead of 41,42,43
two generators are independent: FAIL, throws NotImplementedException instead of 1,2,1
two services share one generator: FAIL, throws NotImplementedException instead of ORD-1,INV-2,ORD-3
each service with its own: FAIL, throws NotImplementedException instead of ORD-1,INV-1
a start of 0: FAIL, throws NotImplementedException instead of throws ArgumentOutOfRangeException
0 of 6 checks pass