Windows App Platforms: WPF, WinUI 3, WinForms, MAUI & More

# Check the SDK: 10.0.x with x >= 13 at the time of writing
dotnet --version

# Solution and shared code (no Windows dependency)
dotnet new sln -n BookshelfDesktop
dotnet new classlib -n Bookshelf.Core -f net10.0
dotnet new wpf -n Bookshelf.Wpf -f net10.0
dotnet new winforms -n Bookshelf.WinForms -f net10.0

dotnet sln add Bookshelf.Core Bookshelf.Wpf Bookshelf.WinForms
dotnet add Bookshelf.Core package CommunityToolkit.Mvvm --version 8.4.2
dotnet add Bookshelf.Wpf reference Bookshelf.Core
dotnet add Bookshelf.WinForms reference Bookshelf.Core

# See which WinUI templates are installed or available
dotnet new list winui
dotnet new search winui

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <UseWPF>true</UseWPF>
    <RootNamespace>Bookshelf.Wpf</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\Bookshelf.Core\Bookshelf.Core.csproj" />
  </ItemGroup>

</Project>

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <UseWindowsForms>true</UseWindowsForms>
    <RootNamespace>Bookshelf.WinForms</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\Bookshelf.Core\Bookshelf.Core.csproj" />
  </ItemGroup>

</Project>

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
    <RootNamespace>Bookshelf.WinUI</RootNamespace>
    <Platforms>x86;x64;ARM64</Platforms>
    <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
    <UseWinUI>true</UseWinUI>
    <EnableMsixTooling>true</EnableMsixTooling>
    <WindowsPackageType>None</WindowsPackageType>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.WindowsAppSDK" Version="2.5.1" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\Bookshelf.Core\Bookshelf.Core.csproj" />
  </ItemGroup>

</Project>

// Bookshelf.Core/Book.cs
namespace Bookshelf.Core;

public sealed record Book(int Id, string Title, string Author, int Year = 0, decimal Price = 0m, string? Isbn = null);

// Bookshelf.Core/IBookRepository.cs
namespace Bookshelf.Core;

public interface IBookRepository
{
    Task<IReadOnlyList<Book>> GetAllAsync(CancellationToken cancellationToken);
    Task<Book?> GetByIdAsync(int id, CancellationToken cancellationToken);
    Task<Book> AddAsync(Book book, CancellationToken cancellationToken);
    Task UpdateAsync(Book book, CancellationToken cancellationToken);
    Task DeleteAsync(int id, CancellationToken cancellationToken);
}

// Bookshelf.Core/IDialogService.cs
namespace Bookshelf.Desktop;

using Bookshelf.Core;

public interface IDialogService
{
    Task<bool> ConfirmAsync(string title, string message);

    /// <summary>Shows the add/edit dialog. Returns null when the user cancels.</summary>
    Task<Book?> EditBookAsync(Book? existing);
}

// Bookshelf.Core/InMemoryBookRepository.cs
namespace Bookshelf.Core;

public sealed class InMemoryBookRepository : IBookRepository
{
    private readonly List<Book> _books =
    [
        new(1, "The Pragmatic Programmer", "Andrew Hunt", 1999),
        new(2, "Refactoring", "Martin Fowler", 1999),
        new(3, "Domain-Driven Design", "Eric Evans", 2003),
    ];

    public Task<IReadOnlyList<Book>> GetAllAsync(CancellationToken cancellationToken)
        => Task.FromResult<IReadOnlyList<Book>>(_books.ToList());

    public Task<Book?> GetByIdAsync(int id, CancellationToken cancellationToken)
        => Task.FromResult(_books.FirstOrDefault(book => book.Id == id));

    public Task<Book> AddAsync(Book book, CancellationToken cancellationToken)
    {
        var added = book with { Id = _books.Count == 0 ? 1 : _books.Max(b => b.Id) + 1 };
        _books.Add(added);
        return Task.FromResult(added);
    }

    public Task UpdateAsync(Book book, CancellationToken cancellationToken)
    {
        var index = _books.FindIndex(b => b.Id == book.Id);
        if (index >= 0)
        {
            _books[index] = book;
        }

        return Task.CompletedTask;
    }

    public Task DeleteAsync(int id, CancellationToken cancellationToken)
    {
        _books.RemoveAll(book => book.Id == id);
        return Task.CompletedTask;
    }
}

// Bookshelf.Core/BooksViewModel.cs
using System.Collections.ObjectModel;
using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public partial class BookViewModel(Book book) : ObservableObject
{
    public Book Model { get; } = book;

    public int Id => Model.Id;

    public string Title => Model.Title;

    public string Author => Model.Author;

    public int Year => Model.Year;

    [ObservableProperty]
    public partial bool IsFavorite { get; set; }
}

public partial class BooksViewModel(IBookRepository repository, IDialogService dialogs) : ObservableObject
{
    private List<BookViewModel> _all = [];

    public ObservableCollection<BookViewModel> Books { get; } = [];

    [ObservableProperty]
    public partial string? SearchText { get; set; }

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(DeleteSelectedCommand))]
    public partial BookViewModel? SelectedBook { get; set; }

    partial void OnSearchTextChanged(string? value) => ApplyFilter();

    [RelayCommand(IncludeCancelCommand = true)]
    private async Task LoadAsync(CancellationToken cancellationToken)
    {
        var books = await repository.GetAllAsync(cancellationToken);
        _all = books.Select(book => new BookViewModel(book)).ToList();
        ApplyFilter();
    }

    [RelayCommand(CanExecute = nameof(CanDeleteSelected))]
    private async Task DeleteSelectedAsync()
    {
        if (SelectedBook is not { } book)
        {
            return;
        }

        if (!await dialogs.ConfirmAsync("Delete book", $"Delete \"{book.Title}\"?"))
        {
            return;
        }

        await repository.DeleteAsync(book.Id, CancellationToken.None);
        _all.Remove(book);
        ApplyFilter();
    }

    private bool CanDeleteSelected() => SelectedBook is not null;

    private void ApplyFilter()
    {
        var text = SearchText?.Trim();
        var matches = string.IsNullOrEmpty(text)
            ? _all
            : _all.Where(b => b.Title.Contains(text, StringComparison.CurrentCultureIgnoreCase)
                           || b.Author.Contains(text, StringComparison.CurrentCultureIgnoreCase)).ToList();

        Books.Clear();
        foreach (var book in matches)
        {
            Books.Add(book);
        }
    }
}

<!-- Bookshelf.Wpf/MainWindow.xaml -->
<Window x:Class="Bookshelf.Wpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Bookshelf Desktop" Height="420" Width="680">
    <Grid Margin="12" RowDefinitions="Auto, *, Auto">
        <TextBox Grid.Row="0"
                 Margin="0,0,0,8"
                 AutomationProperties.Name="Search books"
                 Text="{Binding SearchText, UpdateSourceTrigger=PropertyChanged}" />

        <DataGrid Grid.Row="1"
                  AutoGenerateColumns="False"
                  IsReadOnly="True"
                  ItemsSource="{Binding Books}"
                  SelectedItem="{Binding SelectedBook}">
            <DataGrid.Columns>
                <DataGridTextColumn Header="Title" Binding="{Binding Title}" Width="2*" />
                <DataGridTextColumn Header="Author" Binding="{Binding Author}" Width="*" />
                <DataGridTextColumn Header="Year" Binding="{Binding Year}" />
            </DataGrid.Columns>
        </DataGrid>

        <Button Grid.Row="2"
                Margin="0,8,0,0"
                HorizontalAlignment="Right"
                Content="Delete"
                Command="{Binding DeleteSelectedCommand}" />
    </Grid>
</Window>

// Bookshelf.Wpf/MainWindow.xaml.cs
using Bookshelf.Desktop.ViewModels;

namespace Bookshelf.Wpf;

public partial class MainWindow : System.Windows.Window
{
    public MainWindow(BooksViewModel viewModel)
    {
        InitializeComponent();
        DataContext = viewModel;
        Loaded += async (_, _) => await viewModel.LoadCommand.ExecuteAsync(null);
    }
}

// Bookshelf.Wpf/WpfDialogService.cs
using Bookshelf.Core;
using Bookshelf.Desktop;

namespace Bookshelf.Wpf;

public sealed class WpfDialogService : IDialogService
{
    public Task<bool> ConfirmAsync(string title, string message)
    {
        var result = System.Windows.MessageBox.Show(
            message, title, System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxImage.Question);
        return Task.FromResult(result == System.Windows.MessageBoxResult.Yes);
    }

    // The add/edit dialog is shown on the Windows, Dialogs & Navigation page; this comparison has no edit screen.
    public Task<Book?> EditBookAsync(Book? existing) => Task.FromResult<Book?>(null);
}

// Bookshelf.Wpf/App.xaml.cs  (remove StartupUri from App.xaml)
using Bookshelf.Core;
using Bookshelf.Desktop.ViewModels;

namespace Bookshelf.Wpf;

public partial class App : System.Windows.Application
{
    protected override void OnStartup(System.Windows.StartupEventArgs e)
    {
        base.OnStartup(e);
        var viewModel = new BooksViewModel(new InMemoryBookRepository(), new WpfDialogService());
        new MainWindow(viewModel).Show();
    }
}

<!-- Bookshelf.WinUI/MainWindow.xaml -->
<Window
    x:Class="Bookshelf.WinUI.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:vm="using:Bookshelf.Desktop.ViewModels">

    <Grid x:Name="RootGrid" Padding="12" RowSpacing="8">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>

        <TextBox Grid.Row="0"
                 AutomationProperties.Name="Search books"
                 Text="{x:Bind ViewModel.SearchText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />

        <ListView Grid.Row="1"
                  ItemsSource="{x:Bind ViewModel.Books}"
                  SelectedItem="{x:Bind ViewModel.SelectedBook, Mode=TwoWay}">
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="vm:BookViewModel">
                    <StackPanel Padding="0,4">
                        <TextBlock Text="{x:Bind Title}" Style="{StaticResource BodyStrongTextBlockStyle}" />
                        <TextBlock Text="{x:Bind Author}" />
                    </StackPanel>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>

        <Button Grid.Row="2"
                HorizontalAlignment="Right"
                Content="Delete"
                Command="{x:Bind ViewModel.DeleteSelectedCommand}" />
    </Grid>
</Window>

// Bookshelf.WinUI/MainWindow.xaml.cs
using Bookshelf.Desktop.ViewModels;
using Microsoft.UI.Xaml;

namespace Bookshelf.WinUI;

public sealed partial class MainWindow : Window
{
    public MainWindow(BooksViewModel viewModel)
    {
        ViewModel = viewModel;
        InitializeComponent();
        RootGrid.Loaded += async (_, _) => await ViewModel.LoadCommand.ExecuteAsync(null);
    }

    public BooksViewModel ViewModel { get; }
}

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

namespace Bookshelf.WinForms;

public sealed class MainForm : Form
{
    private readonly BooksViewModel _viewModel;
    private readonly BindingSource _books = new();
    private readonly TextBox _search = new() { Dock = DockStyle.Top };
    private readonly DataGridView _grid = new()
    {
        Dock = DockStyle.Fill,
        ReadOnly = true,
        AllowUserToAddRows = false,
        SelectionMode = DataGridViewSelectionMode.FullRowSelect,
        MultiSelect = false,
    };
    private readonly Button _delete = new() { Text = "Delete", Dock = DockStyle.Bottom };

    public MainForm(BooksViewModel viewModel)
    {
        _viewModel = viewModel;
        Text = "Bookshelf Desktop";
        ClientSize = new Size(680, 420);
        AccessibleName = "Bookshelf Desktop";
        _search.AccessibleName = "Search books";

        Controls.Add(_grid);
        Controls.Add(_search);
        Controls.Add(_delete);

        // BookViewModel has more public properties than the grid should show, so declare the columns.
        _grid.AutoGenerateColumns = false;
        _grid.Columns.Add(new DataGridViewTextBoxColumn { DataPropertyName = nameof(BookViewModel.Title), HeaderText = "Title" });
        _grid.Columns.Add(new DataGridViewTextBoxColumn { DataPropertyName = nameof(BookViewModel.Author), HeaderText = "Author" });
        _grid.Columns.Add(new DataGridViewTextBoxColumn { DataPropertyName = nameof(BookViewModel.Year), HeaderText = "Year" });

        _books.DataSource = viewModel.Books;
        _grid.DataSource = _books;
        _search.DataBindings.Add(nameof(TextBox.Text), viewModel, nameof(BooksViewModel.SearchText),
            false, DataSourceUpdateMode.OnPropertyChanged);
        _delete.Command = viewModel.DeleteSelectedCommand;

        // ObservableCollection does not implement IBindingList, so refresh the BindingSource by hand
        viewModel.Books.CollectionChanged += OnBooksChanged;
        _grid.SelectionChanged += (_, _) => viewModel.SelectedBook = _books.Current as BookViewModel;
    }

    protected override async void OnShown(EventArgs e)
    {
        base.OnShown(e);
        await _viewModel.LoadCommand.ExecuteAsync(null);
    }

    private void OnBooksChanged(object? sender, NotifyCollectionChangedEventArgs e)
        => _books.ResetBindings(false);
}

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

internal static class Program
{
    [STAThread]
    private static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new MainForm(new BooksViewModel(new InMemoryBookRepository(), new MessageBoxDialogService())));
    }
}

// Bookshelf.WinForms/MessageBoxDialogService.cs
using Bookshelf.Core;
using Bookshelf.Desktop;

namespace Bookshelf.WinForms;

internal sealed class MessageBoxDialogService : IDialogService
{
    public Task<bool> ConfirmAsync(string title, string message)
        => Task.FromResult(MessageBox.Show(message, title, MessageBoxButtons.YesNo, MessageBoxIcon.Question)
                           == DialogResult.Yes);

    public Task<Book?> EditBookAsync(Book? existing) => Task.FromResult<Book?>(null);
}