Navigation, Dialogs & Services in MVVM

namespace Bookshelf.Core;

public interface INavigationService
{
    bool CanGoBack { get; }

    /// <summary>Shows the view for <typeparamref name="TViewModel"/>.</summary>
    void NavigateTo<TViewModel>() where TViewModel : class;

    /// <summary>Shows the view and hands <paramref name="parameter"/> to the new view model.</summary>
    void NavigateTo<TViewModel>(object parameter) where TViewModel : class;

    void GoBack();
}

/// <summary>Optional: implemented by view models that accept a navigation parameter.</summary>
public interface INavigationAware
{
    void OnNavigatedTo(object? parameter);
}

using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using Microsoft.Extensions.DependencyInjection;

namespace Bookshelf.Desktop;

public sealed partial class ViewModelNavigationService(IServiceProvider services)
    : ObservableObject, INavigationService
{
    private readonly Stack<object> _backStack = new();

    /// <summary>The view model shown by the shell; bound by the ContentControl.</summary>
    [ObservableProperty]
    public partial object? Current { get; set; }

    public bool CanGoBack => _backStack.Count > 0;

    public void NavigateTo<TViewModel>() where TViewModel : class => Show<TViewModel>(null);

    public void NavigateTo<TViewModel>(object parameter) where TViewModel : class => Show<TViewModel>(parameter);

    public void GoBack()
    {
        if (_backStack.Count == 0)
        {
            return;
        }

        // The previous instance is restored, so scroll position, selection and edits survive.
        Current = _backStack.Pop();
        OnPropertyChanged(nameof(CanGoBack));
    }

    private void Show<TViewModel>(object? parameter) where TViewModel : class
    {
        var next = services.GetRequiredService<TViewModel>();
        if (next is INavigationAware aware)
        {
            aware.OnNavigatedTo(parameter);
        }

        if (Current is not null)
        {
            _backStack.Push(Current);
        }

        Current = next;
        OnPropertyChanged(nameof(CanGoBack));
    }
}

using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class ShellViewModel : ObservableObject
{
    private readonly INavigationService _navigation;

    public ShellViewModel(ViewModelNavigationService navigation)
    {
        Navigation = navigation;
        _navigation = navigation;
        navigation.PropertyChanged += (_, e) =>
        {
            if (e.PropertyName == nameof(INavigationService.CanGoBack))
            {
                GoBackCommand.NotifyCanExecuteChanged();
            }
        };
        _navigation.NavigateTo<BooksViewModel>();
    }

    /// <summary>Exposed so XAML can bind Navigation.Current.</summary>
    public ViewModelNavigationService Navigation { get; }

    private bool CanGoBack => _navigation.CanGoBack;

    [RelayCommand(CanExecute = nameof(CanGoBack))]
    private void GoBack() => _navigation.GoBack();
}

<Window x:Class="Bookshelf.Desktop.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="clr-namespace:Bookshelf.Desktop.ViewModels"
        xmlns:views="clr-namespace:Bookshelf.Desktop.Views"
        Title="Bookshelf Desktop" Width="900" Height="600">
    <Window.Resources>
        <!-- No x:Key: these are implicit templates, matched by DataType. -->
        <DataTemplate DataType="{x:Type vm:BooksViewModel}">
            <views:BooksView />
        </DataTemplate>
        <DataTemplate DataType="{x:Type vm:BookEditorViewModel}">
            <views:BookEditorView />
        </DataTemplate>
    </Window.Resources>
    <DockPanel>
        <ToolBar DockPanel.Dock="Top">
            <Button Content="Back" Command="{Binding GoBackCommand}" />
        </ToolBar>
        <ContentControl Content="{Binding Navigation.Current}" />
    </DockPanel>
</Window>

using Bookshelf.Core;
using Bookshelf.Desktop.ViewModels;
using Microsoft.Extensions.DependencyInjection;

namespace Bookshelf.Desktop;

public static class NavigationRegistration
{
    public static IServiceCollection AddBookshelfNavigation(this IServiceCollection services)
    {
        // One instance, visible both as the concrete type (for the shell) and as the interface.
        services.AddSingleton<ViewModelNavigationService>();
        services.AddSingleton<INavigationService>(sp => sp.GetRequiredService<ViewModelNavigationService>());

        // View models are transient: every NavigateTo gets a fresh instance.
        services.AddTransient<BooksViewModel>();
        services.AddTransient<BookEditorViewModel>();
        services.AddSingleton<ShellViewModel>();
        return services;
    }
}

using Bookshelf.Core;

namespace Bookshelf.Desktop.Tests;

public sealed class FakeDialogService : IDialogService
{
    public bool ConfirmAnswer { get; set; } = true;
    public Book? EditResult { get; set; }
    public List<string> Questions { get; } = [];

    public Task<bool> ConfirmAsync(string title, string message)
    {
        Questions.Add(message);
        return Task.FromResult(ConfirmAnswer);
    }

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

<NavigationView x:Name="NavView"
                PaneDisplayMode="Auto"
                IsBackButtonVisible="Visible"
                IsBackEnabled="{x:Bind ContentFrame.CanGoBack, Mode=OneWay}"
                SelectionChanged="OnSelectionChanged"
                BackRequested="OnBackRequested">
    <NavigationView.MenuItems>
        <NavigationViewItem Content="Books" Tag="Bookshelf.WinUI.Views.BooksPage" />
        <NavigationViewItem Content="Statistics" Tag="Bookshelf.WinUI.Views.StatisticsPage" />
    </NavigationView.MenuItems>
    <Frame x:Name="ContentFrame" />
</NavigationView>

using Bookshelf.WinUI.Views;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media.Animation;

namespace Bookshelf.WinUI;

public sealed partial class ShellPage : Page
{
    public ShellPage() => InitializeComponent();

    private void OnSelectionChanged(NavigationView sender, NavigationViewSelectionChangedEventArgs args)
    {
        if (args.IsSettingsSelected)
        {
            ContentFrame.Navigate(typeof(SettingsPage), null, new EntranceNavigationTransitionInfo());
        }
        else if (args.SelectedItemContainer?.Tag is string pageTypeName
                 && Type.GetType(pageTypeName) is { } pageType)
        {
            ContentFrame.Navigate(pageType, null, new EntranceNavigationTransitionInfo());
        }
    }

    private void OnBackRequested(NavigationView sender, NavigationViewBackRequestedEventArgs args)
    {
        if (ContentFrame.CanGoBack)
        {
            ContentFrame.GoBack();
        }
    }
}

using Bookshelf.Core;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

namespace Bookshelf.WinUI;

public sealed class WinUiDialogService : IDialogService
{
    private XamlRoot? _xamlRoot;

    /// <summary>Called by the shell page when it is loaded.</summary>
    public void Attach(XamlRoot xamlRoot) => _xamlRoot = xamlRoot;

    public async Task<bool> ConfirmAsync(string title, string message)
    {
        var dialog = new ContentDialog
        {
            XamlRoot = _xamlRoot,
            Title = title,
            Content = message,
            PrimaryButtonText = "Yes",
            CloseButtonText = "No",
            DefaultButton = ContentDialogButton.Close,
        };
        return await dialog.ShowAsync() == ContentDialogResult.Primary;
    }

    public Task<Book?> EditBookAsync(Book? existing)
    {
        // Same contract: show a ContentDialog subclass that hosts the editor and return Book or null.
        throw new NotImplementedException("Bookshelf editor ContentDialog is not shown on this page.");
    }
}