MVVM 패턴

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Windows.Input;

var viewModel = new CartViewModel(new Cart(unitPrice: 1200));
var view = new ConsoleView();
// XAML의 {Binding TotalText} 같은 선언을 흉내 낸다. 속성은 문자열 이름으로만 가리킨다.
var binder = new Binder(viewModel, view);
binder.OneWay("Quantity", "quantityLabel");
binder.OneWay("TotalText", "totalLabel");
binder.Command(viewModel.CheckoutCommand, "checkoutButton");

Console.WriteLine("> set Quantity = 3");
viewModel.Quantity = 3; // 양방향 바인딩이 있다면 입력 상자가 이 대입을 한다.
view.Click("checkoutButton");
view.Click("checkoutButton");

// Model: 화면을 모르는 업무 데이터와 규칙
sealed class Cart(int unitPrice)
{
    public int Quantity { get; set; }
    public int Total => unitPrice * Quantity;
    public void Checkout() => Quantity = 0;
}

// 실행할 동작과 실행 가능 조건을 대리자로 받는 ICommand 구현
sealed class RelayCommand(Action execute, Func<bool> canExecute) : ICommand
{
    public event EventHandler? CanExecuteChanged;
    public bool CanExecute(object? parameter) => canExecute();
    public void Execute(object? parameter) => execute();
    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}

// ViewModel: 화면에 보일 상태와 명령을 가진다. View 타입은 참조하지 않는다.
sealed class CartViewModel : INotifyPropertyChanged
{
    private readonly Cart cart;
    private readonly RelayCommand checkout;

    public CartViewModel(Cart cart)
    {
        this.cart = cart;
        checkout = new RelayCommand(Checkout, () => cart.Quantity > 0);
    }

    public event PropertyChangedEventHandler? PropertyChanged;
    public ICommand CheckoutCommand => checkout;

    public int Quantity
    {
        get => cart.Quantity;
        set
        {
            if (value == cart.Quantity) return;
            cart.Quantity = value;
            QuantityChanged();
        }
    }

    // 계산 속성: 값을 따로 저장하지 않고 Model에서 매번 만든다.
    public string TotalText => cart.Total.ToString("N0", CultureInfo.InvariantCulture);

    private void Checkout()
    {
        cart.Checkout();
        QuantityChanged();
    }

    // Quantity에 기대는 계산 속성과 명령 상태도 직접 알려야 한다.
    private void QuantityChanged()
    {
        Raise(nameof(Quantity));
        Raise(nameof(TotalText));
        checkout.RaiseCanExecuteChanged();
    }

    private void Raise([CallerMemberName] string name = "") =>
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}

// View: 화면 요소에 값을 쓰고 클릭을 이벤트로 내보낸다. ViewModel을 모른다.
sealed class ConsoleView
{
    public event Action<string>? Clicked;
    public void SetText(string control, string text) => Console.WriteLine($"  {control}.Text = \"{text}\"");
    public void SetEnabled(string control, bool enabled) => Console.WriteLine($"  {control}.IsEnabled = {enabled}");
    public void Click(string control)
    {
        Console.WriteLine($"> click {control}");
        Clicked?.Invoke(control);
    }
}

// 프레임워크의 바인딩 엔진을 대신하는 작은 바인더.
// PropertyChanged와 CanExecuteChanged를 구독해 화면 값을 고친다.
sealed class Binder
{
    private readonly INotifyPropertyChanged source;
    private readonly ConsoleView view;
    private readonly Dictionary<string, string> targets = new();

    public Binder(INotifyPropertyChanged source, ConsoleView view)
    {
        this.source = source;
        this.view = view;
        source.PropertyChanged += (_, e) =>
        {
            if (e.PropertyName is { } name && targets.ContainsKey(name)) Push(name);
        };
    }

    public void OneWay(string property, string control)
    {
        targets[property] = control;
        Push(property);
    }

    public void Command(ICommand command, string control)
    {
        view.SetEnabled(control, command.CanExecute(null));
        command.CanExecuteChanged += (_, _) => view.SetEnabled(control, command.CanExecute(null));
        // 비활성 버튼은 눌러도 명령을 실행하지 않는다.
        view.Clicked += clicked =>
        {
            if (clicked == control && command.CanExecute(null)) command.Execute(null);
        };
    }

    private void Push(string property)
    {
        var value = source.GetType().GetProperty(property)!.GetValue(source);
        view.SetText(targets[property], Convert.ToString(value, CultureInfo.InvariantCulture) ?? "");
    }
}

  quantityLabel.Text = "0"
  totalLabel.Text = "0"
  checkoutButton.IsEnabled = False
> set Quantity = 3
  quantityLabel.Text = "3"
  totalLabel.Text = "3,600"
  checkoutButton.IsEnabled = True
> click checkoutButton
  quantityLabel.Text = "0"
  totalLabel.Text = "0"
  checkoutButton.IsEnabled = False
> click checkoutButton

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Windows.Input;

var viewModel = new CartViewModel(new Cart(unitPrice: 1200, stock: 5));
var view = new ConsoleView();
var binder = new Binder(viewModel, view);
binder.TwoWay("QuantityText", "quantityBox");
binder.OneWay("TotalTxt", "totalLabel"); // 속성 이름 오타
binder.OneWay("TotalText", "totalLabel");
binder.OneWay("Status", "statusLabel");
binder.Command(viewModel.CheckoutCommand, "checkoutButton");

view.Type("quantityBox", "abc");
view.Click("checkoutButton");
view.Type("quantityBox", "12");
view.Type("quantityBox", "7");
view.Click("checkoutButton");
view.Type("quantityBox", "5");
view.Click("checkoutButton");

// 주문 결과. 실패도 예외가 아니라 값으로 돌려준다.
sealed record CheckoutResult(bool Ok, string Message);

// Model: 재고 규칙을 가진 업무 객체. 화면 문자열이나 입력 형식은 모른다.
sealed class Cart(int unitPrice, int stock)
{
    public int Total(int quantity) => unitPrice * quantity;
    public CheckoutResult Checkout(int quantity)
    {
        if (quantity > stock) return new CheckoutResult(false, $"only {stock} in stock");
        stock -= quantity;
        return new CheckoutResult(true, $"ordered {quantity}, {stock} left");
    }
}

sealed class RelayCommand(Action execute, Func<bool> canExecute) : ICommand
{
    public event EventHandler? CanExecuteChanged;
    public bool CanExecute(object? parameter) => canExecute();
    public void Execute(object? parameter) => execute();
    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}

// ViewModel: 입력 문자열을 받아 검증하고, 오류와 명령 상태를 함께 공개한다.
sealed class CartViewModel : INotifyPropertyChanged, INotifyDataErrorInfo
{
    private const int MaxPerOrder = 10;
    private readonly Cart cart;
    private readonly RelayCommand checkout;
    private string quantityText = "";
    private int? quantity = 0;
    private string? quantityError;
    private string status = "ready";

    public CartViewModel(Cart cart)
    {
        this.cart = cart;
        checkout = new RelayCommand(Checkout, () => quantity is > 0 && !HasErrors);
    }

    public event PropertyChangedEventHandler? PropertyChanged;
    public event EventHandler<DataErrorsChangedEventArgs>? ErrorsChanged;
    public ICommand CheckoutCommand => checkout;

    public string QuantityText
    {
        get => quantityText;
        set
        {
            if (value == quantityText) return;
            quantityText = value;
            Validate();
            Raise();
            Raise(nameof(TotalText));
            checkout.RaiseCanExecuteChanged();
        }
    }

    // 계산 속성: 입력이 올바르지 않으면 합계 대신 "-"를 보인다.
    public string TotalText =>
        quantity is { } q ? cart.Total(q).ToString("N0", CultureInfo.InvariantCulture) : "-";

    public string Status
    {
        get => status;
        private set
        {
            if (value == status) return;
            status = value;
            Raise();
        }
    }

    public bool HasErrors => quantityError is not null;

    public IEnumerable GetErrors(string? propertyName) =>
        propertyName == nameof(QuantityText) && quantityError is { } e ? new[] { e } : Array.Empty<string>();

    // 형식과 1회 주문 한도는 ViewModel이 바로 검사한다. 재고는 Model이 주문 때 판단한다.
    private void Validate()
    {
        string? error = null;
        quantity = null;
        if (quantityText.Length == 0) quantity = 0;
        else if (!int.TryParse(quantityText, NumberStyles.None, CultureInfo.InvariantCulture, out var q))
            error = "enter a whole number";
        else if (q < 1 || q > MaxPerOrder) error = $"enter 1 to {MaxPerOrder}";
        else quantity = q;

        if (error == quantityError) return;
        quantityError = error;
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(QuantityText)));
    }

    private void Checkout()
    {
        var result = cart.Checkout(quantity ?? 0);
        Status = result.Ok ? result.Message : "checkout failed: " + result.Message;
        if (result.Ok) QuantityText = "";
    }

    private void Raise([CallerMemberName] string name = "") =>
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}

sealed class ConsoleView
{
    public event Action<string, string>? Edited;
    public event Action<string>? Clicked;
    public void SetText(string control, string text) => Console.WriteLine($"  {control}.Text = \"{text}\"");
    public void SetEnabled(string control, bool enabled) => Console.WriteLine($"  {control}.IsEnabled = {enabled}");
    public void SetErrors(string control, IEnumerable<string> errors) =>
        Console.WriteLine($"  {control}.Errors = [{string.Join(", ", errors)}]");
    public void Type(string control, string text)
    {
        Console.WriteLine($"> type {control} \"{text}\"");
        Edited?.Invoke(control, text);
    }
    public void Click(string control)
    {
        Console.WriteLine($"> click {control}");
        Clicked?.Invoke(control);
    }
}

// 프레임워크의 바인딩 엔진을 대신하는 작은 바인더.
sealed class Binder
{
    private readonly INotifyPropertyChanged source;
    private readonly ConsoleView view;
    private readonly Dictionary<string, string> targets = new();

    public Binder(INotifyPropertyChanged source, ConsoleView view)
    {
        this.source = source;
        this.view = view;
        source.PropertyChanged += (_, e) =>
        {
            if (e.PropertyName is { } name && targets.ContainsKey(name)) Push(name);
        };
        if (source is INotifyDataErrorInfo errors)
            errors.ErrorsChanged += (_, e) =>
            {
                if (e.PropertyName is { } name && targets.TryGetValue(name, out var control))
                    view.SetErrors(control, errors.GetErrors(name).Cast<string>());
            };
    }

    public void OneWay(string property, string control)
    {
        // 이름이 틀려도 예외를 던지지 않고 기록만 남긴다. 화면에는 아무 값도 가지 않는다.
        if (source.GetType().GetProperty(property) is null)
        {
            Console.WriteLine($"  binding error: '{property}' not found on {source.GetType().Name}");
            return;
        }
        targets[property] = control;
        Push(property);
    }

    public void TwoWay(string property, string control)
    {
        OneWay(property, control);
        view.Edited += (edited, text) =>
        {
            if (edited == control) source.GetType().GetProperty(property)!.SetValue(source, text);
        };
    }

    public void Command(ICommand command, string control)
    {
        view.SetEnabled(control, command.CanExecute(null));
        command.CanExecuteChanged += (_, _) => view.SetEnabled(control, command.CanExecute(null));
        view.Clicked += clicked =>
        {
            if (clicked != control) return;
            if (!command.CanExecute(null))
            {
                Console.WriteLine($"  {control} is disabled, command not executed");
                return;
            }
            command.Execute(null);
        };
    }

    private void Push(string property)
    {
        var value = source.GetType().GetProperty(property)!.GetValue(source);
        view.SetText(targets[property], Convert.ToString(value, CultureInfo.InvariantCulture) ?? "");
    }
}

  quantityBox.Text = ""
  binding error: 'TotalTxt' not found on CartViewModel
  totalLabel.Text = "0"
  statusLabel.Text = "ready"
  checkoutButton.IsEnabled = False
> type quantityBox "abc"
  quantityBox.Errors = [enter a whole number]
  quantityBox.Text = "abc"
  totalLabel.Text = "-"
  checkoutButton.IsEnabled = False
> click checkoutButton
  checkoutButton is disabled, command not executed
> type quantityBox "12"
  quantityBox.Errors = [enter 1 to 10]
  quantityBox.Text = "12"
  totalLabel.Text = "-"
  checkoutButton.IsEnabled = False
> type quantityBox "7"
  quantityBox.Errors = []
  quantityBox.Text = "7"
  totalLabel.Text = "8,400"
  checkoutButton.IsEnabled = True
> click checkoutButton
  statusLabel.Text = "checkout failed: only 5 in stock"
> type quantityBox "5"
  quantityBox.Text = "5"
  totalLabel.Text = "6,000"
  checkoutButton.IsEnabled = True
> click checkoutButton
  statusLabel.Text = "ordered 5, 0 left"
  quantityBox.Text = ""
  totalLabel.Text = "0"
  checkoutButton.IsEnabled = False

type Listener = (property: string) => void;

// INotifyPropertyChanged 대신 쓰는 최소한의 관찰 가능 객체
class Observable {
  readonly #listeners: Listener[] = [];
  subscribe(listener: Listener): void { this.#listeners.push(listener); }
  protected notify(property: string): void {
    for (const listener of this.#listeners) listener(property);
  }
}

// ICommand와 같은 모양: 실행, 실행 가능 여부, 그 여부가 바뀌었다는 알림
class RelayCommand {
  readonly #changed: Array<() => void> = [];
  constructor(private readonly run: () => void, private readonly can: () => boolean) {}
  canExecute(): boolean { return this.can(); }
  execute(): void { this.run(); }
  onCanExecuteChanged(listener: () => void): void { this.#changed.push(listener); }
  raiseCanExecuteChanged(): void { for (const listener of this.#changed) listener(); }
}

type CheckoutResult = { ok: boolean; message: string };

// Model: 재고 규칙만 안다.
class Cart {
  constructor(private readonly unitPrice: number, private stock: number) {}
  total(quantity: number): number { return this.unitPrice * quantity; }
  checkout(quantity: number): CheckoutResult {
    if (quantity > this.stock) return { ok: false, message: `only ${this.stock} in stock` };
    this.stock -= quantity;
    return { ok: true, message: `ordered ${quantity}, ${this.stock} left` };
  }
}

const maxPerOrder = 10;
const format = new Intl.NumberFormat("en-US");

// ViewModel: 입력 문자열, 계산된 합계, 오류, 명령을 공개한다. View를 모른다.
class CartViewModel extends Observable {
  #quantityText = "";
  #quantity: number | null = 0;
  #error: string | null = null;
  #status = "ready";
  readonly checkoutCommand: RelayCommand;

  constructor(private readonly cart: Cart) {
    super();
    this.checkoutCommand = new RelayCommand(
      () => this.#checkout(),
      () => this.#quantity !== null && this.#quantity > 0 && this.#error === null);
  }

  get quantityText(): string { return this.#quantityText; }
  set quantityText(value: string) {
    if (value === this.#quantityText) return;
    this.#quantityText = value;
    this.#validate();
    this.notify("quantityText");
    this.notify("totalText");
    this.checkoutCommand.raiseCanExecuteChanged();
  }
  get totalText(): string {
    return this.#quantity === null ? "-" : format.format(this.cart.total(this.#quantity));
  }
  get status(): string { return this.#status; }
  get errors(): string[] { return this.#error === null ? [] : [this.#error]; }

  #validate(): void {
    let error: string | null = null;
    this.#quantity = null;
    if (this.#quantityText.length === 0) this.#quantity = 0;
    else if (!/^[0-9]+$/.test(this.#quantityText)) error = "enter a whole number";
    else {
      const q = Number(this.#quantityText);
      if (q < 1 || q > maxPerOrder) error = `enter 1 to ${maxPerOrder}`;
      else this.#quantity = q;
    }
    if (error === this.#error) return;
    this.#error = error;
    this.notify("errors");
  }

  #checkout(): void {
    const result = this.cart.checkout(this.#quantity ?? 0);
    this.#status = result.ok ? result.message : "checkout failed: " + result.message;
    this.notify("status");
    if (result.ok) this.quantityText = "";
  }
}

// View: 화면 요소에 값을 쓰고 입력과 클릭을 알린다.
class ConsoleView {
  readonly edited: Array<(control: string, text: string) => void> = [];
  readonly clicked: Array<(control: string) => void> = [];
  setText(control: string, text: string): void { console.log(`  ${control}.Text = "${text}"`); }
  setEnabled(control: string, enabled: boolean): void {
    console.log(`  ${control}.IsEnabled = ${enabled ? "True" : "False"}`);
  }
  setErrors(control: string, errors: string[]): void {
    console.log(`  ${control}.Errors = [${errors.join(", ")}]`);
  }
  type(control: string, text: string): void {
    console.log(`> type ${control} "${text}"`);
    for (const listener of this.edited) listener(control, text);
  }
  click(control: string): void {
    console.log(`> click ${control}`);
    for (const listener of this.clicked) listener(control);
  }
}

// CartViewModel의 공개 속성 가운데 문자열인 것만 고른 이름 목록
type TextProperty = {
  [K in keyof CartViewModel]: CartViewModel[K] extends string ? K : never
}[keyof CartViewModel];

// 바인딩 엔진을 대신하는 작은 바인더. 속성 이름을 타입으로 받으므로 오타는 컴파일 오류가 된다.
class Binder {
  readonly #targets = new Map<string, string>();
  constructor(private readonly source: CartViewModel, private readonly view: ConsoleView) {
    source.subscribe((property) => {
      const control = this.#targets.get(property);
      if (control !== undefined) this.#push(property, control);
      if (property === "errors") {
        const box = this.#targets.get("quantityText");
        if (box !== undefined) view.setErrors(box, source.errors);
      }
    });
  }
  oneWay(property: TextProperty, control: string): void {
    this.#targets.set(property, control);
    this.#push(property, control);
  }
  twoWay(property: "quantityText", control: string): void {
    this.oneWay(property, control);
    this.view.edited.push((edited, text) => { if (edited === control) this.source[property] = text; });
  }
  command(command: RelayCommand, control: string): void {
    this.view.setEnabled(control, command.canExecute());
    command.onCanExecuteChanged(() => this.view.setEnabled(control, command.canExecute()));
    this.view.clicked.push((clicked) => {
      if (clicked !== control) return;
      if (!command.canExecute()) {
        console.log(`  ${control} is disabled, command not executed`);
        return;
      }
      command.execute();
    });
  }
  #push(property: string, control: string): void {
    this.view.setText(control, this.source[property as TextProperty]);
  }
}

const viewModel = new CartViewModel(new Cart(1200, 5));
const view = new ConsoleView();
const binder = new Binder(viewModel, view);
binder.twoWay("quantityText", "quantityBox");
binder.oneWay("totalText", "totalLabel");
binder.oneWay("status", "statusLabel");
binder.command(viewModel.checkoutCommand, "checkoutButton");

view.type("quantityBox", "abc");
view.click("checkoutButton");
view.type("quantityBox", "7");
view.click("checkoutButton");
view.type("quantityBox", "5");
view.click("checkoutButton");

  quantityBox.Text = ""
  totalLabel.Text = "0"
  statusLabel.Text = "ready"
  checkoutButton.IsEnabled = False
> type quantityBox "abc"
  quantityBox.Errors = [enter a whole number]
  quantityBox.Text = "abc"
  totalLabel.Text = "-"
  checkoutButton.IsEnabled = False
> click checkoutButton
  checkoutButton is disabled, command not executed
> type quantityBox "7"
  quantityBox.Errors = []
  quantityBox.Text = "7"
  totalLabel.Text = "8,400"
  checkoutButton.IsEnabled = True
> click checkoutButton
  statusLabel.Text = "checkout failed: only 5 in stock"
> type quantityBox "5"
  quantityBox.Text = "5"
  totalLabel.Text = "6,000"
  checkoutButton.IsEnabled = True
> click checkoutButton
  statusLabel.Text = "ordered 5, 0 left"
  quantityBox.Text = ""
  totalLabel.Text = "0"
  checkoutButton.IsEnabled = False