WinUI 3 & the Windows App SDK

using Bookshelf.Core;
using Bookshelf.Data;
using Bookshelf.Desktop;
using Bookshelf.Desktop.ViewModels;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.UI.Xaml;
using Microsoft.Windows.AppLifecycle;

namespace Bookshelf.WinUI;

public partial class App : Application
{
    /// <summary>The running application, typed.</summary>
    public static new App Current => (App)Application.Current;

    public IServiceProvider Services { get; }

    public MainWindow? MainWindow { get; private set; }

    public App()
    {
        Services = ConfigureServices();
        InitializeComponent();
    }

    private static ServiceProvider ConfigureServices()
    {
        var services = new ServiceCollection();

        services.AddBookshelfData();                 // IBookRepository: EF Core + SQLite, from Bookshelf.Data
        services.AddSingleton<WinUiDialogService>();
        services.AddSingleton<IDialogService>(sp => sp.GetRequiredService<WinUiDialogService>());

        // One BooksViewModel for the whole shell, so that a protocol activation can select a book
        // in the same instance that the page is bound to.
        services.AddSingleton<BooksViewModel>();

        return services.BuildServiceProvider();
    }

    protected override async void OnLaunched(LaunchActivatedEventArgs args)
    {
        // A plain ServiceCollection never starts IHostedService registrations, so run the ones
        // AddBookshelfData adds (DatabaseInitializer migrates the database) before any page queries it.
        foreach (var hostedService in Services.GetServices<IHostedService>())
        {
            await hostedService.StartAsync(CancellationToken.None);
        }

        MainWindow = new MainWindow();
        MainWindow.Activate();

        // Launch, file and protocol activations all arrive through the same routine.
        ActivationRouter.Handle(AppInstance.GetCurrent().GetActivatedEventArgs());
    }
}

<Window
    x:Class="Bookshelf.WinUI.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <Window.SystemBackdrop>
    <MicaBackdrop Kind="BaseAlt" />
  </Window.SystemBackdrop>

  <Grid>
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="*" />
    </Grid.RowDefinitions>

    <TitleBar x:Name="AppTitleBar"
              Title="Bookshelf"
              Subtitle="Desktop"
              IsBackButtonVisible="True"
              IsBackButtonEnabled="{x:Bind ContentFrame.CanGoBack, Mode=OneWay}"
              BackRequested="OnTitleBarBackRequested"
              IsPaneToggleButtonVisible="True"
              PaneToggleRequested="OnTitleBarPaneToggleRequested">
      <TitleBar.IconSource>
        <FontIconSource Glyph="&#xE8F1;" />
      </TitleBar.IconSource>
    </TitleBar>

    <NavigationView x:Name="NavView"
                    Grid.Row="1"
                    PaneDisplayMode="Auto"
                    IsBackButtonVisible="Collapsed"
                    IsPaneToggleButtonVisible="False"
                    IsSettingsVisible="True"
                    SelectionChanged="OnNavSelectionChanged">
      <NavigationView.MenuItems>
        <NavigationViewItem Content="Books" Tag="books" AutomationProperties.Name="Books">
          <NavigationViewItem.Icon>
            <FontIcon Glyph="&#xE8F1;" />
          </NavigationViewItem.Icon>
        </NavigationViewItem>
        <NavigationViewItem Content="Favorites" Tag="favorites" AutomationProperties.Name="Favorite books">
          <NavigationViewItem.Icon>
            <FontIcon Glyph="&#xE734;" />
          </NavigationViewItem.Icon>
        </NavigationViewItem>
      </NavigationView.MenuItems>

      <Frame x:Name="ContentFrame" IsTabStop="True" />
    </NavigationView>
  </Grid>
</Window>

using Bookshelf.WinUI.Views;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media.Animation;
using Windows.Graphics;

namespace Bookshelf.WinUI;

public sealed partial class MainWindow : Window
{
    private static readonly Dictionary<string, Type> Pages = new()
    {
        ["books"] = typeof(BooksPage),
        ["favorites"] = typeof(FavoritesPage),
    };

    public MainWindow()
    {
        InitializeComponent();

        // In code, in the constructor: setting it in XAML is an error, and setting it later can flash
        // the system title bar first.
        ExtendsContentIntoTitleBar = true;
        SetTitleBar(AppTitleBar);

        Title = "Bookshelf";
        AppWindow.Resize(new SizeInt32(1200, 800));

        App.Current.Services.GetRequiredService<WinUiDialogService>().Attach(Content.XamlRoot);

        NavView.SelectedItem = NavView.MenuItems[0];
    }

    private void OnNavSelectionChanged(NavigationView sender, NavigationViewSelectionChangedEventArgs args)
    {
        if (args.IsSettingsSelected)
        {
            Navigate(typeof(SettingsPage), args.RecommendedNavigationTransitionInfo);
        }
        else if (args.SelectedItemContainer?.Tag is string tag && Pages.TryGetValue(tag, out Type? pageType))
        {
            Navigate(pageType, args.RecommendedNavigationTransitionInfo);
        }
    }

    private void Navigate(Type pageType, NavigationTransitionInfo transition)
    {
        // Do not stack duplicate entries when the selected item is invoked again.
        if (ContentFrame.CurrentSourcePageType != pageType)
        {
            ContentFrame.Navigate(pageType, null, transition);
        }
    }

    private void OnTitleBarBackRequested(TitleBar sender, object args)
    {
        if (ContentFrame.CanGoBack)
        {
            ContentFrame.GoBack();
        }
    }

    private void OnTitleBarPaneToggleRequested(TitleBar sender, object args) =>
        NavView.IsPaneOpen = !NavView.IsPaneOpen;
}

<Page
    x:Class="Bookshelf.WinUI.Views.BooksPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:Bookshelf.WinUI"
    xmlns:vm="using:Bookshelf.Desktop.ViewModels"
    x:DefaultBindMode="OneWay"
    Loaded="OnLoaded">

  <Page.Resources>
    <DataTemplate x:Key="BookRowTemplate" x:DataType="vm:BookViewModel">
      <Grid Padding="8,6" ColumnSpacing="12">
        <Grid.ColumnDefinitions>
          <ColumnDefinition Width="*" />
          <ColumnDefinition Width="Auto" />
        </Grid.ColumnDefinitions>
        <StackPanel>
          <TextBlock Text="{x:Bind Title, Mode=OneTime}" Style="{StaticResource BodyStrongTextBlockStyle}" />
          <TextBlock Text="{x:Bind local:BookFormat.ByLine(Author, Year), Mode=OneTime}"
                     Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
        </StackPanel>
        <ToggleButton Grid.Column="1"
                      AutomationProperties.Name="Favorite"
                      IsChecked="{x:Bind IsFavorite, Mode=TwoWay}">
          <FontIcon Glyph="&#xE734;" />
        </ToggleButton>
      </Grid>
    </DataTemplate>
  </Page.Resources>

  <Grid Padding="24,12,24,24" RowSpacing="12" ColumnSpacing="24">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="2*" />
      <ColumnDefinition Width="*" MinWidth="280" />
    </Grid.ColumnDefinitions>

    <CommandBar Grid.ColumnSpan="2" DefaultLabelPosition="Right" Background="Transparent">
      <AppBarButton Icon="Add" Label="Add" Command="{x:Bind ViewModel.AddBookCommand}" />
      <AppBarButton Icon="Edit" Label="Edit" Command="{x:Bind ViewModel.EditSelectedCommand}" />
      <AppBarButton Icon="Delete" Label="Delete" Command="{x:Bind ViewModel.DeleteSelectedCommand}" />
      <AppBarSeparator />
      <AppBarButton Icon="Refresh" Label="Reload" Command="{x:Bind ViewModel.LoadCommand}" />
    </CommandBar>

    <Grid Grid.Row="1" RowSpacing="8">
      <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="*" />
      </Grid.RowDefinitions>

      <StackPanel Orientation="Horizontal" Spacing="8">
        <TextBox Width="320" PlaceholderText="Search books"
                 AutomationProperties.Name="Search books"
                 Text="{x:Bind ViewModel.SearchText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        <Button Content="Clear search" Click="{x:Bind ClearSearch}" />
      </StackPanel>

      <ListView Grid.Row="1"
                ItemsSource="{x:Bind ViewModel.Books, Mode=OneTime}"
                SelectedItem="{x:Bind ViewModel.SelectedBook, Mode=TwoWay}"
                ItemTemplate="{StaticResource BookRowTemplate}"
                AutomationProperties.Name="Books" />
    </Grid>

    <!-- Created only while a book is selected; unloaded again when the selection is cleared. -->
    <StackPanel x:Name="DetailsPane"
                x:Load="{x:Bind IsNotNull(ViewModel.SelectedBook)}"
                Grid.Row="1" Grid.Column="1" Spacing="8">
      <TextBlock Text="{x:Bind ViewModel.SelectedBook.Title, FallbackValue=''}"
                 Style="{StaticResource SubtitleTextBlockStyle}" />
      <TextBlock Text="{x:Bind ViewModel.SelectedBook.Author, FallbackValue=''}" />
      <TextBlock Text="{x:Bind local:BookFormat.Price(ViewModel.SelectedBook.Price)}" />
      <TextBlock Text="{x:Bind ViewModel.SelectedBook.Model.Isbn, FallbackValue='No ISBN'}"
                 Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
    </StackPanel>

    <InfoBar Grid.Row="2" Grid.ColumnSpan="2"
             IsOpen="True" IsClosable="False" Severity="Informational"
             Message="{x:Bind ViewModel.StatusMessage}" />
  </Grid>
</Page>

using Bookshelf.Desktop.ViewModels;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

namespace Bookshelf.WinUI.Views;

public sealed partial class BooksPage : Page
{
    // x:Bind resolves "ViewModel.SearchText" against this class, so the view model is a property here.
    public BooksViewModel ViewModel { get; }

    public BooksPage()
    {
        // Frame.Navigate creates the page with its parameterless constructor, so the page asks the container.
        ViewModel = App.Current.Services.GetRequiredService<BooksViewModel>();
        InitializeComponent();
    }

    private async void OnLoaded(object sender, RoutedEventArgs e) =>
        await ViewModel.LoadCommand.ExecuteAsync(null);

    // A parameterless method can be the target of an event binding: Click="{x:Bind ClearSearch}".
    private void ClearSearch() => ViewModel.SearchText = string.Empty;

    // A function binding: re-evaluated when ViewModel.SelectedBook changes.
    public static bool IsNotNull(object? value) => value is not null;
}

public static class BookFormat
{
    public static string ByLine(string? author, int year) =>
        year > 0 ? $"{author}, {year}" : author ?? string.Empty;

    public static string Price(decimal price) => price.ToString("C");
}

<!-- BookFormat.ByLine is defined on the page above; Describe, Currency and the sys: prefix
     (xmlns:sys="using:System") are illustrative helpers for this snippet -->
<!-- Static function with two bound arguments: re-evaluated if Author or Year change -->
<TextBlock Text="{x:Bind local:BookFormat.ByLine(Author, Year), Mode=OneWay}" />

<!-- A system function, with a string constant (single quotes) as the first argument -->
<TextBlock Text="{x:Bind sys:String.Concat('Price: ', local:BookFormat.Price(Price))}" />

<!-- Two-way function binding needs BindBack -->
<TextBox Text="{x:Bind local:Currency.Display(Price), BindBack=local:Currency.Parse, Mode=TwoWay}" />

<!-- Pathless cast: passes the item itself as an argument -->
<TextBlock Text="{x:Bind local:BookFormat.Describe((vm:BookViewModel))}" />

<!-- Mica as the window backdrop -->
<Window.SystemBackdrop>
  <MicaBackdrop />
</Window.SystemBackdrop>

<!-- Mica Alt -->
<Window.SystemBackdrop>
  <MicaBackdrop Kind="BaseAlt" />
</Window.SystemBackdrop>

<!-- Acrylic on a flyout -->
<Flyout>
  <Flyout.SystemBackdrop>
    <DesktopAcrylicBackdrop />
  </Flyout.SystemBackdrop>
</Flyout>

<Grid Width="300" Height="200">
  <SystemBackdropElement CornerRadius="8">
    <SystemBackdropElement.SystemBackdrop>
      <DesktopAcrylicBackdrop />
    </SystemBackdropElement.SystemBackdrop>
  </SystemBackdropElement>

  <StackPanel Padding="16" Spacing="4" VerticalAlignment="Center">
    <TextBlock Text="{x:Bind ViewModel.SelectedBook.Title, FallbackValue=''}"
               Style="{StaticResource SubtitleTextBlockStyle}" />
    <TextBlock Text="{x:Bind ViewModel.SelectedBook.Author, FallbackValue=''}" />
  </StackPanel>
</Grid>

// The backdrop can be switched at run time, for example from a settings page.
private void OnBackdropChanged(string kind)
{
    DetailsBackdrop.SystemBackdrop = kind switch
    {
        "Mica"    => new MicaBackdrop { Kind = MicaKind.Base },
        "MicaAlt" => new MicaBackdrop { Kind = MicaKind.BaseAlt },
        _         => new DesktopAcrylicBackdrop(),
    };
}

<TitleBar x:Name="AppTitleBar" Title="Bookshelf">
  <TitleBar.Resources>
    <HorizontalAlignment x:Key="TitleBarContentHorizontalAlignment">Stretch</HorizontalAlignment>
  </TitleBar.Resources>
  <TitleBar.Content>
    <Grid ColumnSpacing="8">
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*" />
        <ColumnDefinition Width="Auto" />
      </Grid.ColumnDefinitions>
      <AutoSuggestBox MaxWidth="480" VerticalAlignment="Center"
                      PlaceholderText="Search books" QueryIcon="Find"
                      AutomationProperties.Name="Search books" />
      <Button Grid.Column="1" x:Name="SyncButton" Content="Sync" />
    </Grid>
  </TitleBar.Content>
</TitleBar>

// Interactive controls are clickable and empty space is draggable by default (2.1.3 and later).
// Override on the smallest element that needs it:
TitleBar.SetIsDragRegion(SyncButton, false);   // clickable
SyncButton.ClearValue(TitleBar.IsDragRegionProperty);

// After adding or resizing title bar content at run time:
AppTitleBar.RecomputeDragRegions();

using System.Diagnostics;
using System.Runtime.InteropServices;
using Microsoft.UI.Dispatching;
using Microsoft.UI.Xaml;
using Microsoft.Windows.AppLifecycle;

namespace Bookshelf.WinUI;

public static class Program
{
    private const string InstanceKey = "Bookshelf.Desktop.Main";

    [STAThread]
    private static int Main(string[] args)
    {
        WinRT.ComWrappersSupport.InitializeComWrappers();

        if (DecideRedirection())
        {
            return 0;
        }

        Application.Start(_ =>
        {
            var context = new DispatcherQueueSynchronizationContext(DispatcherQueue.GetForCurrentThread());
            SynchronizationContext.SetSynchronizationContext(context);
            _ = new App();
        });

        return 0;
    }

    private static bool DecideRedirection()
    {
        AppActivationArguments args = AppInstance.GetCurrent().GetActivatedEventArgs();
        AppInstance keyInstance = AppInstance.FindOrRegisterForKey(InstanceKey);

        if (keyInstance.IsCurrent)
        {
            keyInstance.Activated += OnActivated;
            return false;
        }

        RedirectActivationTo(args, keyInstance);
        return true;
    }

    // Raised in the first instance when a later process redirects its activation to it.
    private static void OnActivated(object? sender, AppActivationArguments args) =>
        ActivationRouter.HandleFromAnyThread(args);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string? lpName);

    [DllImport("kernel32.dll")]
    private static extern bool SetEvent(IntPtr hEvent);

    [DllImport("ole32.dll")]
    private static extern uint CoWaitForMultipleObjects(uint dwFlags, uint dwMilliseconds, ulong nHandles, IntPtr[] pHandles, out uint dwIndex);

    [DllImport("user32.dll")]
    private static extern bool SetForegroundWindow(IntPtr hWnd);

    // Redirect on another thread and wait with a non-blocking COM wait, so the STA keeps pumping messages.
    private static void RedirectActivationTo(AppActivationArguments args, AppInstance keyInstance)
    {
        IntPtr redirectEventHandle = CreateEvent(IntPtr.Zero, true, false, null);

        Task.Run(() =>
        {
            keyInstance.RedirectActivationToAsync(args).AsTask().Wait();
            SetEvent(redirectEventHandle);
        });

        const uint CWMO_DEFAULT = 0;
        const uint INFINITE = 0xFFFFFFFF;
        _ = CoWaitForMultipleObjects(CWMO_DEFAULT, INFINITE, 1, [redirectEventHandle], out _);

        // Give the first instance's window the foreground.
        using Process process = Process.GetProcessById((int)keyInstance.ProcessId);
        SetForegroundWindow(process.MainWindowHandle);
    }
}

using Bookshelf.Desktop.ViewModels;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Windows.AppLifecycle;
using Windows.ApplicationModel.Activation;

namespace Bookshelf.WinUI;

public static class ActivationRouter
{
    /// <summary>Called from a thread that is not necessarily the UI thread.</summary>
    public static void HandleFromAnyThread(AppActivationArguments args)
    {
        // Marshal explicitly: the lifecycle documentation does not state which thread raises Activated.
        if (App.Current.MainWindow?.DispatcherQueue is { } queue)
        {
            queue.TryEnqueue(() => Handle(args));
        }
    }

    public static void Handle(AppActivationArguments args)
    {
        switch (args.Kind)
        {
            case ExtendedActivationKind.Protocol when args.Data is IProtocolActivatedEventArgs protocol:
                ShowBookFromUri(protocol.Uri);
                break;

            case ExtendedActivationKind.File when args.Data is IFileActivatedEventArgs file:
                // Import the first file: file.Files[0] is an IStorageItem.
                break;

            case ExtendedActivationKind.Launch when args.Data is ILaunchActivatedEventArgs launch:
                // launch.Arguments holds the raw command-line text.
                break;
        }

        // A reactivation should always bring the window forward.
        App.Current.MainWindow?.Activate();
    }

    // bookshelf://book/42 selects the book with Id 42.
    private static void ShowBookFromUri(Uri uri)
    {
        if (uri.Host == "book" && int.TryParse(uri.AbsolutePath.Trim('/'), out int id))
        {
            BooksViewModel viewModel = App.Current.Services.GetRequiredService<BooksViewModel>();
            viewModel.SelectedBook = viewModel.Books.FirstOrDefault(b => b.Id == id);
        }
    }
}

<!-- Package.appxmanifest: inside <Application> ... <Extensions> -->
<uap:Extension Category="windows.protocol">
  <uap:Protocol Name="bookshelf">
    <uap:DisplayName>Bookshelf Desktop</uap:DisplayName>
  </uap:Protocol>
</uap:Extension>

// Unpackaged only: register a protocol (and file types) once, for the current user.
string exePath = Environment.ProcessPath!;
ActivationRegistrationManager.RegisterForProtocolActivation(
    "bookshelf",
    exePath + ",1",
    "Bookshelf Desktop",
    exePath);

<PropertyGroup>
  <WindowsPackageType>None</WindowsPackageType>
  <!-- Optional: carry the Windows App SDK runtime with the app instead of requiring it on the machine -->
  <WindowsAppSDKSelfContained>true</WindowsAppSDKSelfContained>
</PropertyGroup>