Windows Forms on .NET

// Bookshelf.WinForms/MainForm.Designer.cs
namespace Bookshelf.WinForms;

partial class MainForm
{
    private System.ComponentModel.IContainer? components;

    private TableLayoutPanel _root = null!;
    private FlowLayoutPanel _toolbar = null!;
    private Label _searchLabel = null!;
    private TextBox _search = null!;
    private Button _add = null!;
    private Button _edit = null!;
    private Button _delete = null!;
    private SplitContainer _split = null!;
    private DataGridView _grid = null!;
    private TableLayoutPanel _details = null!;
    private TextBox _titleBox = null!;
    private TextBox _authorBox = null!;
    private TextBox _yearBox = null!;
    private TextBox _priceBox = null!;
    private CheckBox _favorite = null!;
    private StatusStrip _status = null!;
    private ToolStripStatusLabel _statusLabel = null!;

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            components?.Dispose();
        }

        base.Dispose(disposing);
    }

    private void InitializeComponent()
    {
        components = new System.ComponentModel.Container();
        _root = new TableLayoutPanel();
        _toolbar = new FlowLayoutPanel();
        _searchLabel = new Label();
        _search = new TextBox();
        _add = new Button();
        _edit = new Button();
        _delete = new Button();
        _split = new SplitContainer();
        _grid = new DataGridView();
        _details = new TableLayoutPanel();
        _titleBox = new TextBox();
        _authorBox = new TextBox();
        _yearBox = new TextBox();
        _priceBox = new TextBox();
        _favorite = new CheckBox();
        _status = new StatusStrip();
        _statusLabel = new ToolStripStatusLabel();

        SuspendLayout();

        // Two bands: toolbar (AutoSize) and work area (100 percent); the StatusStrip docks to the bottom of the form.
        _root.Dock = DockStyle.Fill;
        _root.ColumnCount = 1;
        _root.RowCount = 2;
        _root.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
        _root.RowStyles.Add(new RowStyle(SizeType.AutoSize));
        _root.RowStyles.Add(new RowStyle(SizeType.Percent, 100F));
        _root.Controls.Add(_toolbar, 0, 0);
        _root.Controls.Add(_split, 0, 1);

        // Toolbar: a FlowLayoutPanel that sizes to its content.
        _toolbar.AutoSize = true;
        _toolbar.Dock = DockStyle.Fill;
        _toolbar.WrapContents = false;
        _toolbar.Padding = new Padding(4);
        _searchLabel.Text = "&Search";
        _searchLabel.AutoSize = true;
        _searchLabel.Anchor = AnchorStyles.Left;
        _search.Width = 260;
        _search.AccessibleName = "Search books";
        _add.Text = "&Add";
        _add.AutoSize = true;
        _edit.Text = "&Edit";
        _edit.AutoSize = true;
        _delete.Text = "&Delete";
        _delete.AutoSize = true;
        _toolbar.Controls.AddRange([_searchLabel, _search, _add, _edit, _delete]);

        // Work area: grid on the left, details on the right.
        _split.Dock = DockStyle.Fill;
        _split.SplitterDistance = 480;
        _split.Panel1.Controls.Add(_grid);
        _split.Panel2.Controls.Add(_details);

        _grid.Dock = DockStyle.Fill;
        _grid.ReadOnly = true;
        _grid.AllowUserToAddRows = false;
        _grid.AllowUserToDeleteRows = false;
        _grid.AutoGenerateColumns = false;
        _grid.MultiSelect = false;
        _grid.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
        _grid.RowHeadersVisible = false;
        _grid.AccessibleName = "Books";
        _grid.Columns.AddRange(
            new DataGridViewTextBoxColumn
            {
                Name = "Title",
                HeaderText = "Title",
                DataPropertyName = "Title",
                AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
            },
            new DataGridViewTextBoxColumn
            {
                Name = "Author",
                HeaderText = "Author",
                DataPropertyName = "Author",
                AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
            },
            new DataGridViewTextBoxColumn
            {
                Name = "Year",
                HeaderText = "Year",
                DataPropertyName = "Year",
                Width = 60,
            });

        // Details pane: label column sized to content, value column takes the rest.
        _details.Dock = DockStyle.Top;
        _details.AutoSize = true;
        _details.ColumnCount = 2;
        _details.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize));
        _details.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
        _details.Padding = new Padding(8);
        AddRow(_details, 0, "Title", _titleBox);
        AddRow(_details, 1, "Author", _authorBox);
        AddRow(_details, 2, "Year", _yearBox);
        AddRow(_details, 3, "Price", _priceBox);
        _favorite.Text = "&Favorite";
        _favorite.AutoSize = true;
        _details.Controls.Add(_favorite, 1, 4);

        // Status strip docks to the bottom of the form.
        _statusLabel.Text = "Ready";
        _status.Items.Add(_statusLabel);

        // The Fill control is added first so it is laid out last; the StatusStrip then takes its edge first.
        Controls.Add(_root);
        Controls.Add(_status);

        AutoScaleDimensions = new SizeF(96F, 96F);
        AutoScaleMode = AutoScaleMode.Dpi;
        ClientSize = new Size(900, 540);
        MinimumSize = new Size(640, 360);
        Text = "Bookshelf Desktop";
        ResumeLayout(false);
        PerformLayout();
    }

    private static void AddRow(TableLayoutPanel table, int row, string caption, TextBox value)
    {
        var label = new Label { Text = caption, AutoSize = true, Anchor = AnchorStyles.Left };
        value.ReadOnly = true;
        value.Dock = DockStyle.Fill;
        value.AccessibleName = caption;
        table.Controls.Add(label, 0, row);
        table.Controls.Add(value, 1, row);
    }
}

// The two-line version when no filtering is needed
using Microsoft.EntityFrameworkCore;

_books.DataSource = _viewModel.Books.ToBindingList();

// Bookshelf.WinForms/MainForm.cs
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using Bookshelf.Desktop.ViewModels;

namespace Bookshelf.WinForms;

public partial class MainForm : Form
{
    private readonly BooksViewModel _viewModel;
    private readonly BindingSource _books = new();

    public MainForm(BooksViewModel viewModel)
    {
        _viewModel = viewModel;
        InitializeComponent();
        BindControls();
    }

    private void BindControls()
    {
        // The grid and the details pane share one BindingSource, so they share one current item.
        _grid.DataSource = _books;
        ApplyFilter();
        _viewModel.Books.CollectionChanged += OnBooksChanged;
        _viewModel.PropertyChanged += OnViewModelPropertyChanged;

        // Details pane: one-way (DataSourceUpdateMode.Never) because BookViewModel wraps an immutable Book.
        _titleBox.DataBindings.Add(nameof(TextBox.Text), _books, nameof(BookViewModel.Title), false, DataSourceUpdateMode.Never);
        _authorBox.DataBindings.Add(nameof(TextBox.Text), _books, nameof(BookViewModel.Author), false, DataSourceUpdateMode.Never);
        _yearBox.DataBindings.Add(nameof(TextBox.Text), _books, nameof(BookViewModel.Year), false, DataSourceUpdateMode.Never);

        var price = new Binding(nameof(TextBox.Text), _books, nameof(BookViewModel.Price), formattingEnabled: true)
        {
            DataSourceUpdateMode = DataSourceUpdateMode.Never,
            FormatString = "C2",
            FormatInfo = CultureInfo.CurrentCulture,
        };
        _priceBox.DataBindings.Add(price);

        // IsFavorite has a public setter on BookViewModel, so this one is two-way and immediate.
        _favorite.DataBindings.Add(nameof(CheckBox.Checked), _books, nameof(BookViewModel.IsFavorite), false, DataSourceUpdateMode.OnPropertyChanged);

        // View model <-> search box. OnPropertyChanged writes on every keystroke, not on leaving the box.
        _search.DataBindings.Add(nameof(TextBox.Text), _viewModel, nameof(BooksViewModel.SearchText), false, DataSourceUpdateMode.OnPropertyChanged);

        // Status bar text follows StatusMessage.
        _statusLabel.DataBindings.Add(nameof(ToolStripStatusLabel.Text), _viewModel, nameof(BooksViewModel.StatusMessage));

        // Selection: the BindingSource's current item is the view model's SelectedBook.
        _books.CurrentChanged += (_, _) => _viewModel.SelectedBook = _books.Current as BookViewModel;

        // Commands: Button.Command follows CanExecute (the button is disabled when it returns false).
        _add.Command = _viewModel.AddBookCommand;
        _edit.Command = _viewModel.EditSelectedCommand;
        _delete.Command = _viewModel.DeleteSelectedCommand;
    }

    private void OnBooksChanged(object? sender, NotifyCollectionChangedEventArgs e) => ApplyFilter();

    private void OnViewModelPropertyChanged(object? sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == nameof(BooksViewModel.SearchText))
        {
            ApplyFilter();
        }
    }

    // Rebuilds the list the BindingSource shows. BindingList<T> raises ListChanged for item property changes.
    private void ApplyFilter()
    {
        var text = _viewModel.SearchText?.Trim();
        var visible = string.IsNullOrEmpty(text)
            ? _viewModel.Books.ToList()
            : _viewModel.Books
                .Where(b => b.Title.Contains(text, StringComparison.CurrentCultureIgnoreCase)
                         || b.Author.Contains(text, StringComparison.CurrentCultureIgnoreCase))
                .ToList();

        _books.DataSource = new BindingList<BookViewModel>(visible);
    }

    protected override async void OnShown(EventArgs e)
    {
        base.OnShown(e);

        // async void is acceptable for an event-handler-like override; catch everything inside.
        try
        {
            await _viewModel.LoadCommand.ExecuteAsync(null);
        }
        catch (Exception ex)
        {
            _viewModel.StatusMessage = $"Could not load books: {ex.Message}";
        }
    }
}

// Bookshelf.WinForms/BookEditorForm.cs
using Bookshelf.Desktop.ViewModels;

namespace Bookshelf.WinForms;

public sealed class BookEditorForm : Form
{
    private readonly BookEditorViewModel _viewModel;
    private readonly ErrorProvider _errors = new() { BlinkStyle = ErrorBlinkStyle.NeverBlink };
    private readonly Dictionary<string, Control> _fields = [];

    private readonly TextBox _title = new() { Dock = DockStyle.Fill, AccessibleName = "Title" };
    private readonly TextBox _author = new() { Dock = DockStyle.Fill, AccessibleName = "Author" };
    private readonly NumericUpDown _year = new() { Dock = DockStyle.Fill, Minimum = 0, Maximum = 2100, AccessibleName = "Year" };
    private readonly NumericUpDown _price = new() { Dock = DockStyle.Fill, DecimalPlaces = 2, Maximum = 10000, AccessibleName = "Price" };
    private readonly TextBox _isbn = new() { Dock = DockStyle.Fill, AccessibleName = "ISBN" };
    private readonly Button _ok = new() { Text = "&Save", AutoSize = true };
    private readonly Button _cancel = new() { Text = "&Cancel", AutoSize = true, DialogResult = DialogResult.Cancel };

    public BookEditorForm(BookEditorViewModel viewModel)
    {
        _viewModel = viewModel;

        Text = "Book";
        AutoScaleDimensions = new SizeF(96F, 96F);
        AutoScaleMode = AutoScaleMode.Dpi;
        FormBorderStyle = FormBorderStyle.FixedDialog;
        StartPosition = FormStartPosition.CenterParent;
        MinimizeBox = false;
        MaximizeBox = false;
        ShowInTaskbar = false;
        AcceptButton = _ok;
        CancelButton = _cancel;

        var table = new TableLayoutPanel
        {
            Dock = DockStyle.Fill,
            AutoSize = true,
            AutoSizeMode = AutoSizeMode.GrowAndShrink,
            ColumnCount = 2,
            Padding = new Padding(12),
        };
        table.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize));
        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));

        AddField(table, 0, "&Title", _title, nameof(BookEditorViewModel.Title), nameof(TextBox.Text));
        AddField(table, 1, "&Author", _author, nameof(BookEditorViewModel.Author), nameof(TextBox.Text));
        AddField(table, 2, "&Year", _year, nameof(BookEditorViewModel.Year), nameof(NumericUpDown.Value));
        AddField(table, 3, "&Price", _price, nameof(BookEditorViewModel.Price), nameof(NumericUpDown.Value));
        AddField(table, 4, "&ISBN", _isbn, nameof(BookEditorViewModel.Isbn), nameof(TextBox.Text));

        var buttons = new FlowLayoutPanel
        {
            AutoSize = true,
            FlowDirection = FlowDirection.RightToLeft,
            Dock = DockStyle.Fill,
        };
        buttons.Controls.AddRange([_cancel, _ok]);
        table.Controls.Add(buttons, 1, 5);

        Controls.Add(table);
        AutoSize = true;
        AutoSizeMode = AutoSizeMode.GrowAndShrink;

        _errors.ContainerControl = this;
        _viewModel.ErrorsChanged += (_, e) => ShowErrors(e.PropertyName);
        _ok.Click += OnSaveClicked;
    }

    private void AddField(TableLayoutPanel table, int row, string caption, Control editor, string member, string controlProperty)
    {
        var label = new Label { Text = caption, AutoSize = true, Anchor = AnchorStyles.Left, UseMnemonic = true };
        table.Controls.Add(label, 0, row);
        table.Controls.Add(editor, 1, row);

        // formattingEnabled converts between the control's decimal Value and the view model's int or decimal.
        editor.DataBindings.Add(controlProperty, _viewModel, member, true, DataSourceUpdateMode.OnPropertyChanged);
        _fields[member] = editor;
    }

    private void ShowErrors(string? propertyName)
    {
        foreach (var (member, control) in _fields)
        {
            if (string.IsNullOrEmpty(propertyName) || propertyName == member)
            {
                var messages = _viewModel.GetErrors(member).Select(r => r.ErrorMessage);
                _errors.SetError(control, string.Join(Environment.NewLine, messages));
            }
        }
    }

    private void OnSaveClicked(object? sender, EventArgs e)
    {
        // ToBook() validates every property, including ones the user never touched, and returns null on errors.
        if (_viewModel.ToBook() is null)
        {
            foreach (var member in _fields.Keys)
            {
                ShowErrors(member);
            }

            return;
        }

        DialogResult = DialogResult.OK;
    }
}

<PropertyGroup>
  <ForceDesignerDPIUnaware>true</ForceDesignerDPIUnaware>
  <ApplicationHighDpiMode>DpiUnawareGdiScaled</ApplicationHighDpiMode>
</PropertyGroup>

public sealed class StarRatingControl : Control
{
    protected override CreateParams CreateParams
    {
        get
        {
            // Must run before CreateParams is read from the base class; the constructor is too late.
            SetStyle(ControlStyles.ApplyThemingImplicitly, true);
            return base.CreateParams;
        }
    }
}

// Bookshelf.WinForms/WinFormsDialogService.cs
using Bookshelf.Core;
using Bookshelf.Desktop;
using Bookshelf.Desktop.ViewModels;

namespace Bookshelf.WinForms;

internal sealed class WinFormsDialogService : IDialogService
{
    // The first open form is the main form in this single-window app.
    private static Form? Owner => Application.OpenForms.Count > 0 ? Application.OpenForms[0] : null;

    public Task<bool> ConfirmAsync(string title, string message)
    {
        var answer = MessageBox.Show(Owner, message, title, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
        return Task.FromResult(answer == DialogResult.Yes);
    }

    public async Task<Book?> EditBookAsync(Book? existing)
    {
        var viewModel = new BookEditorViewModel(existing ?? new Book(0, string.Empty, string.Empty));
        using var dialog = new BookEditorForm(viewModel);

        var owner = Owner;
        var result = owner is null
            ? await dialog.ShowDialogAsync()
            : await dialog.ShowDialogAsync(owner);

        return result == DialogResult.OK ? viewModel.ToBook() : null;
    }
}

// Bookshelf.WinForms/MainForm.Export.cs
using System.Text;

namespace Bookshelf.WinForms;

public partial class MainForm
{
    private CancellationTokenSource? _exportCts;

    private async void OnExportClicked(object? sender, EventArgs e)
    {
        using var dialog = new SaveFileDialog { Filter = "CSV files|*.csv", FileName = "bookshelf.csv" };
        if (dialog.ShowDialog(this) != DialogResult.OK)
        {
            return;
        }

        var books = _viewModel.Books.Select(b => b.Model).ToList();
        _exportCts = new CancellationTokenSource();
        _export.Enabled = false;

        try
        {
            await Task.Run(async () =>
            {
                await using var writer = new StreamWriter(dialog.FileName, append: false, Encoding.UTF8);
                for (var i = 0; i < books.Count; i++)
                {
                    _exportCts.Token.ThrowIfCancellationRequested();
                    await writer.WriteLineAsync($"{books[i].Title};{books[i].Author};{books[i].Year}");

                    // Runs on a thread-pool thread, so marshal the UI update back to the UI thread.
                    var done = i + 1;
                    await InvokeAsync(() =>
                    {
                        _viewModel.StatusMessage = $"Exported {done} of {books.Count}";
                    });
                }
            }, _exportCts.Token);

            _viewModel.StatusMessage = "Export complete";
        }
        catch (OperationCanceledException)
        {
            _viewModel.StatusMessage = "Export cancelled";
        }
        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
        {
            MessageBox.Show(this, ex.Message, "Export failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        finally
        {
            _export.Enabled = true;
            _exportCts.Dispose();
            _exportCts = null;
        }
    }
}