MVU Pattern

using System;
using System.Collections.Generic;
using System.Linq;

var runtime = new Runtime(new Model(0));
Console.WriteLine($"{"start",-9} -> {runtime.Screen}");
// Send a predefined message list in order instead of clicking buttons.
Msg[] clicks = [new Increment(), new Increment(), new Decrement(), new Reset()];
foreach (Msg msg in clicks)
{
    runtime.Dispatch(msg);
    Console.WriteLine($"{msg.GetType().Name,-9} -> {runtime.Screen}");
}

// Model: an immutable value containing all state needed by the screen.
sealed record Model(int Count);

// Messages: the set of events that can happen on the screen.
abstract record Msg;
sealed record Increment : Msg;
sealed record Decrement : Msg;
sealed record Reset : Msg;

static class Counter
{
    // Update: calculate the next model from only the current model and message.
    public static Model Update(Model model, Msg msg) => msg switch
    {
        Increment => model with { Count = model.Count + 1 },
        Decrement => model with { Count = model.Count - 1 },
        Reset => model with { Count = 0 },
        // C# has no closed sum types; CS8509 remains even with all subtypes handled, so include a final branch.
        _ => throw new ArgumentOutOfRangeException(nameof(msg), msg, "unknown message"),
    };

    // View: create the screen using only the model.
    public static string View(Model model) => $"[ - ] {model.Count} [ + ]";
}

// Runtime: keep the model in one place and call Update followed by View for each message.
sealed class Runtime(Model initial)
{
    private Model model = initial;
    public string Screen { get; private set; } = Counter.View(initial);

    public void Dispatch(Msg msg)
    {
        model = Counter.Update(model, msg);
        Screen = Counter.View(model);
    }
}

start     -> [ - ] 0 [ + ]
Increment -> [ - ] 1 [ + ]
Increment -> [ - ] 2 [ + ]
Decrement -> [ - ] 1 [ + ]
Reset     -> [ - ] 0 [ + ]

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;

// Fake repository: the first save fails and the second succeeds.
var store = new FakeStore([false, true]);
var runtime = new Runtime(Todo.Init, store.Run);

runtime.Dispatch(new Add("buy milk"));
runtime.Dispatch(new Add("   "));
runtime.Dispatch(new Add("write report"));
runtime.Dispatch(new Toggle(1));
runtime.Dispatch(new Toggle(42));
runtime.Dispatch(new Save());
runtime.Dispatch(new Save());
runtime.RunEffects();
runtime.Dispatch(new Save());
runtime.RunEffects();
runtime.Dispatch(new Undo());

Console.WriteLine($"log: {runtime.Log.Count} messages, store calls: {store.Calls}");
// Fold recorded messages from the initial model without executing commands.
Model replayed = runtime.Log.Aggregate(Todo.Init, (model, msg) => Todo.Update(model, msg).Model);
Console.WriteLine($"replay: {Todo.View(replayed)}");
// List fields compare by reference: use SequenceEqual for items, then align Items and compare the remaining record fields.
bool same = replayed.Items.SequenceEqual(runtime.Model.Items) && replayed with { Items = runtime.Model.Items } == runtime.Model;
Console.WriteLine($"same model: {same}, store calls: {store.Calls}");

sealed record TodoItem(int Id, string Title, bool Done);
sealed record Model(ImmutableList<TodoItem> Items, int NextId, bool Saving, string Note);

// Both user actions and effect results are messages.
abstract record Msg;
sealed record Add(string Title) : Msg;
sealed record Toggle(int Id) : Msg;
sealed record Save : Msg;
sealed record Saved(int Count) : Msg;
sealed record SaveFailed(string Reason) : Msg;
// A message added to Msg without a corresponding Update branch.
sealed record Undo : Msg;

// Command: data describing an effect for the runtime. Update does not execute it.
abstract record Cmd;
sealed record NoCmd : Cmd;
sealed record SaveTodos(ImmutableList<TodoItem> Items) : Cmd;

static class Todo
{
    public static readonly Model Init = new([], 1, false, "");
    static readonly Cmd None = new NoCmd();

    public static (Model Model, Cmd Cmd) Update(Model model, Msg msg) => msg switch
    {
        Add a when string.IsNullOrWhiteSpace(a.Title) => (model with { Note = "title is empty" }, None),
        Add a => (model with
        {
            Items = model.Items.Add(new TodoItem(model.NextId, a.Title, false)),
            NextId = model.NextId + 1,
            Note = "",
        }, None),
        Toggle t when !model.Items.Any(i => i.Id == t.Id) => (model with { Note = $"no todo #{t.Id}" }, None),
        Toggle t => (model with
        {
            Items = model.Items.Select(i => i.Id == t.Id ? i with { Done = !i.Done } : i).ToImmutableList(),
            Note = "",
        }, None),
        // A save requested while saving produces no command.
        Save when model.Saving => (model with { Note = "save already running" }, None),
        Save => (model with { Saving = true, Note = "" }, new SaveTodos(model.Items)),
        Saved s => (model with { Saving = false, Note = $"saved {s.Count}" }, None),
        SaveFailed f => (model with { Saving = false, Note = $"save failed: {f.Reason}" }, None),
        // A message without a handling branch leaves a note without changing items.
        _ => (model with { Note = $"unhandled {msg.GetType().Name}" }, None),
    };

    public static string View(Model model)
    {
        string items = string.Join(", ", model.Items.Select(i => $"#{i.Id}[{(i.Done ? "x" : " ")}] {i.Title}"));
        string state = model.Saving ? "saving" : "idle";
        string note = model.Note == "" ? "" : $" | {model.Note}";
        return $"{items} | {state}{note}";
    }
}

// Runtime: record messages, call Update and queue returned commands for later execution.
sealed class Runtime(Model initial, Func<Cmd, Msg> execute)
{
    private readonly List<Msg> log = [];
    private readonly Queue<Cmd> pending = new();
    public Model Model { get; private set; } = initial;
    public IReadOnlyList<Msg> Log => log;

    public void Dispatch(Msg msg)
    {
        log.Add(msg);
        (Model, Cmd cmd) = Todo.Update(Model, msg);
        Console.WriteLine($"{msg} -> {Todo.View(Model)}");
        if (cmd is not NoCmd) pending.Enqueue(cmd);
    }

    // Effect results return through Update as new messages.
    public void RunEffects()
    {
        while (pending.TryDequeue(out Cmd? cmd)) Dispatch(execute(cmd));
    }
}

sealed class FakeStore(bool[] outcomes)
{
    public int Calls { get; private set; }

    public Msg Run(Cmd cmd)
    {
        if (cmd is not SaveTodos save) return new SaveFailed($"unknown command {cmd.GetType().Name}");
        bool ok = outcomes[Calls];
        Calls++;
        Console.WriteLine($"  effect: save {save.Items.Count} items, call {Calls}");
        return ok ? new Saved(save.Items.Count) : new SaveFailed("disk full");
    }
}

Add { Title = buy milk } -> #1[ ] buy milk | idle
Add { Title =     } -> #1[ ] buy milk | idle | title is empty
Add { Title = write report } -> #1[ ] buy milk, #2[ ] write report | idle
Toggle { Id = 1 } -> #1[x] buy milk, #2[ ] write report | idle
Toggle { Id = 42 } -> #1[x] buy milk, #2[ ] write report | idle | no todo #42
Save { } -> #1[x] buy milk, #2[ ] write report | saving
Save { } -> #1[x] buy milk, #2[ ] write report | saving | save already running
  effect: save 2 items, call 1
SaveFailed { Reason = disk full } -> #1[x] buy milk, #2[ ] write report | idle | save failed: disk full
Save { } -> #1[x] buy milk, #2[ ] write report | saving
  effect: save 2 items, call 2
Saved { Count = 2 } -> #1[x] buy milk, #2[ ] write report | idle | saved 2
Undo { } -> #1[x] buy milk, #2[ ] write report | idle | unhandled Undo
log: 11 messages, store calls: 2
replay: #1[x] buy milk, #2[ ] write report | idle | unhandled Undo
same model: True, store calls: 2

type TodoItem = { readonly id: number; readonly title: string; readonly done: boolean };
type Model = {
  readonly items: readonly TodoItem[];
  readonly nextId: number;
  readonly saving: boolean;
  readonly note: string;
};

// Messages and commands are discriminated unions identified by their kind values.
type Msg =
  | { kind: "add"; title: string }
  | { kind: "toggle"; id: number }
  | { kind: "save" }
  | { kind: "saved"; count: number }
  | { kind: "saveFailed"; reason: string };
type Cmd = { kind: "none" } | { kind: "saveTodos"; items: readonly TodoItem[] };

const init: Model = { items: [], nextId: 1, saving: false, note: "" };
const none: Cmd = { kind: "none" };

function update(model: Model, msg: Msg): [Model, Cmd] {
  switch (msg.kind) {
    case "add":
      if (msg.title.trim() === "") return [{ ...model, note: "title is empty" }, none];
      return [{
        ...model,
        items: [...model.items, { id: model.nextId, title: msg.title, done: false }],
        nextId: model.nextId + 1,
        note: "",
      }, none];
    case "toggle":
      if (!model.items.some((i) => i.id === msg.id)) return [{ ...model, note: `no todo #${msg.id}` }, none];
      return [{ ...model, items: model.items.map((i) => (i.id === msg.id ? { ...i, done: !i.done } : i)), note: "" }, none];
    case "save":
      // A save requested while saving produces no command.
      if (model.saving) return [{ ...model, note: "save already running" }, none];
      return [{ ...model, saving: true, note: "" }, { kind: "saveTodos", items: model.items }];
    case "saved":
      return [{ ...model, saving: false, note: `saved ${msg.count}` }, none];
    case "saveFailed":
      return [{ ...model, saving: false, note: `save failed: ${msg.reason}` }, none];
    default:
      // Handling every kind narrows msg to never. A missing branch causes a compile error here.
      return assertNever(msg);
  }
}

function assertNever(value: never): never {
  throw new Error(`unhandled message ${JSON.stringify(value)}`);
}

function view(model: Model): string {
  const items = model.items.map((i) => `#${i.id}[${i.done ? "x" : " "}] ${i.title}`).join(", ");
  const note = model.note === "" ? "" : ` | ${model.note}`;
  return `${items} | ${model.saving ? "saving" : "idle"}${note}`;
}

// Fake repository: the first save fails and the second succeeds.
class FakeStore {
  calls = 0;
  constructor(private readonly outcomes: readonly boolean[]) {}
  run(cmd: Cmd): Msg {
    if (cmd.kind !== "saveTodos") return { kind: "saveFailed", reason: `unknown command ${cmd.kind}` };
    const ok = this.outcomes[this.calls];
    this.calls++;
    console.log(`  effect: save ${cmd.items.length} items, call ${this.calls}`);
    return ok ? { kind: "saved", count: cmd.items.length } : { kind: "saveFailed", reason: "disk full" };
  }
}

// Runtime: record messages, call update and queue returned commands for later execution.
class Runtime {
  readonly log: Msg[] = [];
  private readonly pending: Cmd[] = [];
  constructor(public model: Model, private readonly execute: (cmd: Cmd) => Msg) {}
  dispatch(msg: Msg): void {
    this.log.push(msg);
    const [next, cmd] = update(this.model, msg);
    this.model = next;
    console.log(`${JSON.stringify(msg)} -> ${view(next)}`);
    if (cmd.kind !== "none") this.pending.push(cmd);
  }
  // Effect results return through update as new messages.
  runEffects(): void {
    for (let cmd = this.pending.shift(); cmd !== undefined; cmd = this.pending.shift()) {
      this.dispatch(this.execute(cmd));
    }
  }
}

const store = new FakeStore([false, true]);
const runtime = new Runtime(init, (cmd) => store.run(cmd));
runtime.dispatch({ kind: "add", title: "buy milk" });
runtime.dispatch({ kind: "add", title: "   " });
runtime.dispatch({ kind: "add", title: "write report" });
runtime.dispatch({ kind: "toggle", id: 1 });
runtime.dispatch({ kind: "save" });
runtime.dispatch({ kind: "save" });
runtime.runEffects();
runtime.dispatch({ kind: "save" });
runtime.runEffects();

console.log(`log: ${runtime.log.length} messages, store calls: ${store.calls}`);
// Fold recorded messages from the initial model without executing commands.
const replayed = runtime.log.reduce((model, msg) => update(model, msg)[0], init);
console.log(`replay: ${view(replayed)}`);
// Both models use the same key order, so compare their complete JSON strings.
console.log(`same model: ${JSON.stringify(replayed) === JSON.stringify(runtime.model)}, store calls: ${store.calls}`);

{"kind":"add","title":"buy milk"} -> #1[ ] buy milk | idle
{"kind":"add","title":"   "} -> #1[ ] buy milk | idle | title is empty
{"kind":"add","title":"write report"} -> #1[ ] buy milk, #2[ ] write report | idle
{"kind":"toggle","id":1} -> #1[x] buy milk, #2[ ] write report | idle
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving | save already running
  effect: save 2 items, call 1
{"kind":"saveFailed","reason":"disk full"} -> #1[x] buy milk, #2[ ] write report | idle | save failed: disk full
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving
  effect: save 2 items, call 2
{"kind":"saved","count":2} -> #1[x] buy milk, #2[ ] write report | idle | saved 2
log: 9 messages, store calls: 2
replay: #1[x] buy milk, #2[ ] write report | idle | saved 2
same model: true, store calls: 2