Performance & Diagnostics

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

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <UseWPF>true</UseWPF>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <SelfContained>false</SelfContained>
    <!-- Precompile the app (and, when self-contained, the framework) at publish time. -->
    <PublishReadyToRun>true</PublishReadyToRun>
    <!-- Symbols (.ni.pdb) so a profiler can resolve R2R code; keep them out of the installer. -->
    <PublishReadyToRunEmitSymbols>true</PublishReadyToRunEmitSymbols>
  </PropertyGroup>

  <ItemGroup>
    <!-- Leave a very large, rarely used assembly out of R2R processing if it bloats the output. -->
    <PublishReadyToRunExclude Include="Bookshelf.Samples.LegacyImport.dll" />
  </ItemGroup>

</Project>

dotnet publish .\Bookshelf.Desktop\Bookshelf.Desktop.csproj -c Release -r win-x64 -p:PublishReadyToRun=true

using System.Diagnostics;
using System.Windows;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Windows.Threading;

namespace Bookshelf.Desktop;

public partial class App : Application
{
    private IHost? _host;

    protected override async void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        // Build the container only: no database access, no file reads, no network calls here.
        _host = Host.CreateDefaultBuilder(e.Args)
            .ConfigureServices((context, services) => services.AddBookshelfDesktop(context.Configuration))
            .Build();

        await _host.StartAsync();

        var window = _host.Services.GetRequiredService<MainWindow>();
        window.Show();

        // Log how long it took until the UI was idle and ready for input. The load command starts
        // after this point, so the books appear while the user can already click.
        var startedAt = Process.GetCurrentProcess().StartTime;
        await Dispatcher.InvokeAsync(
            () => Debug.WriteLine($"Time to interactive: {(DateTime.Now - startedAt).TotalMilliseconds:F0} ms"),
            DispatcherPriority.ApplicationIdle);
    }

    protected override async void OnExit(ExitEventArgs e)
    {
        if (_host is not null)
        {
            await _host.StopAsync();
            _host.Dispose();
        }

        base.OnExit(e);
    }
}

# Which .NET processes are running?
dotnet-counters ps

# Watch the runtime counters of the running app, refreshing every 3 seconds.
dotnet-counters monitor --name Bookshelf.Desktop --refresh-interval 3 --counters System.Runtime

# Watch only garbage collections and total allocated bytes.
dotnet-counters monitor --name Bookshelf.Desktop --counters "System.Runtime[dotnet.gc.collections,dotnet.gc.heap.total_allocated]"

# Record the counters from start-up into a CSV file.
dotnet-counters collect --format csv --output bookshelf-counters.csv -- .\Bookshelf.Desktop.exe

using System.Diagnostics;
using System.Diagnostics.Metrics;
using Bookshelf.Core;

namespace Bookshelf.Desktop.Diagnostics;

public sealed class MeteredBookRepository : IBookRepository
{
    private readonly IBookRepository _inner;
    private readonly Counter<int> _booksLoaded;
    private readonly Histogram<double> _loadDuration;

    public MeteredBookRepository(IBookRepository inner, IMeterFactory meterFactory)
    {
        _inner = inner;

        var meter = meterFactory.Create("Bookshelf.Desktop");
        _booksLoaded = meter.CreateCounter<int>(
            "bookshelf.books_loaded",
            unit: "{book}",
            description: "Books returned by GetAllAsync");
        _loadDuration = meter.CreateHistogram<double>(
            "bookshelf.load_duration",
            unit: "s",
            description: "Time taken by GetAllAsync");
    }

    public async Task<IReadOnlyList<Book>> GetAllAsync(CancellationToken cancellationToken)
    {
        var started = Stopwatch.GetTimestamp();
        var books = await _inner.GetAllAsync(cancellationToken);

        _loadDuration.Record(Stopwatch.GetElapsedTime(started).TotalSeconds);
        _booksLoaded.Add(books.Count);
        return books;
    }

    public Task<Book?> GetByIdAsync(int id, CancellationToken cancellationToken) =>
        _inner.GetByIdAsync(id, cancellationToken);

    public Task<Book> AddAsync(Book book, CancellationToken cancellationToken) =>
        _inner.AddAsync(book, cancellationToken);

    public Task UpdateAsync(Book book, CancellationToken cancellationToken) =>
        _inner.UpdateAsync(book, cancellationToken);

    public Task DeleteAsync(int id, CancellationToken cancellationToken) =>
        _inner.DeleteAsync(id, cancellationToken);
}

using Bookshelf.Core;
using Bookshelf.Data;
using Bookshelf.Desktop.Diagnostics;
using Microsoft.Extensions.DependencyInjection;

namespace Bookshelf.Desktop;

public static class DiagnosticsServiceCollectionExtensions
{
    public static IServiceCollection AddBookshelfMetrics(this IServiceCollection services)
    {
        // IMeterFactory is registered by the Generic Host; the decorator wraps the real repository.
        services.AddSingleton<SqliteBookRepository>();
        services.AddSingleton<IBookRepository>(provider => new MeteredBookRepository(
            provider.GetRequiredService<SqliteBookRepository>(),
            provider.GetRequiredService<System.Diagnostics.Metrics.IMeterFactory>()));
        return services;
    }
}

dotnet-counters monitor --name Bookshelf.Desktop --counters Bookshelf.Desktop

Press p to pause, r to resume, q to quit.
    Status: Running

Name                                              Current Value
[Bookshelf.Desktop]
    bookshelf.books_loaded ({book})                         5,000
    bookshelf.load_duration (s)
        Percentile
        50                                                  0.412
        95                                                  0.418
        99                                                  0.418

# Trace the first seconds of start-up of the published app, then stop with Enter.
dotnet-trace collect -- .\Bookshelf.Desktop.exe

# Trace a running instance for 30 seconds, including database commands.
dotnet-trace collect --name Bookshelf.Desktop --profile dotnet-common,dotnet-sampled-thread-time,database --duration 00:00:00:30

# Convert for a viewer that is not Visual Studio or PerfView (the original .nettrace file is kept).
dotnet-trace convert .\Bookshelf.Desktop_20261023_101500.nettrace --format Speedscope

using Bookshelf.Core;

namespace Bookshelf.Desktop.Services;

public interface IBookChangeFeed
{
    event EventHandler<BookChangedEventArgs>? Changed;
}

public sealed class BookChangedEventArgs(Book book) : EventArgs
{
    public Book Book { get; } = book;
}

// A singleton: it lives as long as the application.
public sealed class BookChangeFeed : IBookChangeFeed
{
    public event EventHandler<BookChangedEventArgs>? Changed;

    public void Publish(Book book) => Changed?.Invoke(this, new BookChangedEventArgs(book));
}

using CommunityToolkit.Mvvm.ComponentModel;
using Bookshelf.Desktop.Services;

namespace Bookshelf.Desktop.ViewModels;

// Created each time the user opens the statistics tab, and meant to die when the tab closes.
public sealed partial class BookStatsViewModel : ObservableObject
{
    private readonly IBookChangeFeed _feed;

    public BookStatsViewModel(IBookChangeFeed feed)
    {
        _feed = feed;

        // LEAK: the singleton feed now holds a delegate to this instance.
        // Every tab the user opens leaves one more BookStatsViewModel alive.
        _feed.Changed += OnBookChanged;
    }

    [ObservableProperty]
    public partial int ChangedBooks { get; set; }

    private void OnBookChanged(object? sender, BookChangedEventArgs e) => ChangedBooks++;
}

using CommunityToolkit.Mvvm.ComponentModel;
using Bookshelf.Desktop.Services;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class BookStatsViewModel : ObservableObject, IDisposable
{
    private readonly IBookChangeFeed _feed;

    public BookStatsViewModel(IBookChangeFeed feed)
    {
        _feed = feed;
        _feed.Changed += OnBookChanged;
    }

    [ObservableProperty]
    public partial int ChangedBooks { get; set; }

    public void Dispose() => _feed.Changed -= OnBookChanged;

    private void OnBookChanged(object? sender, BookChangedEventArgs e) => ChangedBooks++;
}

using CommunityToolkit.Mvvm.ComponentModel;
using Bookshelf.Desktop.Services;
using System.Windows;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class BookStatsViewModel : ObservableObject
{
    public BookStatsViewModel(BookChangeFeed feed)
    {
        // The manager holds a weak reference to this instance, so the feed no longer keeps it alive.
        // The event is found by name through reflection, which is slower than a dedicated manager.
        WeakEventManager<BookChangeFeed, BookChangedEventArgs>.AddHandler(feed, nameof(BookChangeFeed.Changed), OnBookChanged);
    }

    [ObservableProperty]
    public partial int ChangedBooks { get; set; }

    private void OnBookChanged(object? sender, BookChangedEventArgs e) => ChangedBooks++;
}