Mvvm-Toolkit-Di

# CommunityToolkit.Mvvm + `Microsoft.Extensions.DependencyInjection`

The MVVM Toolkit deliberately ships **no DI container** — it composes with

`Microsoft.Extensions.DependencyInjection`, the same container ASP.NET

Core, Worker services, and the .NET Generic Host use.

> **TL;DR.** Build the service provider once at startup (prefer

> `Host.CreateDefaultBuilder()`). Register services and ViewModels.

> Inject through constructors. Avoid `Ioc.Default.GetService<T>()`

> in user code.

---

When to use this skill

- Standing up the composition root for a new XAML app (WPF, WinUI 3,

MAUI, Uno, Avalonia)

- Choosing service/VM lifetimes

- Wiring `IMessenger` once and injecting it into `ObservableRecipient`

ViewModels

- Resolving a page's ViewModel without coupling to a service locator

- Diagnosing "Unable to resolve service for type X while attempting to

activate Y"

For source generators and ViewModel patterns see the **`mvvm-toolkit`**

skill. For Messenger pub/sub see **`mvvm-toolkit-messenger`**.

---

Recommended composition root (Generic Host)

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using CommunityToolkit.Mvvm.Messaging;

public partial class App : Application
{
    public IHost Host { get; }

    public App()
    {
        Host = Microsoft.Extensions.Hosting.Host
            .CreateDefaultBuilder()
            .ConfigureServices((_, services) =>
            {
                services.AddSingleton<IFilesService, FilesService>();
                services.AddSingleton<ISettingsService, SettingsService>();
                services.AddSingleton<IMessenger>(WeakReferenceMessenger.Default);

                services.AddSingleton<ShellViewModel>();
                services.AddTransient<ContactViewModel>();
                services.AddTransient<EditorViewModel>();
            })
            .Build();
    }

    public static T GetService<T>() where T : class =>
        ((App)Current).Host.Services.GetRequiredService<T>();
}

Generic Host benefits:

- `appsettings.json` binding via `Microsoft.Extensions.Configuration`

- Logging via `Microsoft.Extensions.Logging`

- Hosted services (`IHostedService`) for background work

- Scope validation in development builds

> WPF and Windows Forms must integrate the host lifetime with the app

> lifetime — see

> [Use the .NET Generic Host in a WPF app](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/app-development/how-to-use-host-builder).

Without Generic Host

When you only need a service container and want zero extra dependencies:

var services = new ServiceCollection();
services.AddSingleton<IFilesService, FilesService>();
services.AddTransient<ContactViewModel>();
ServiceProvider provider = services.BuildServiceProvider();

---

Constructor injection

Inject services and child ViewModels through the constructor:

public sealed partial class ContactViewModel(
    IFilesService files,
    IMessenger messenger,
    ILogger<ContactViewModel> logger)
    : ObservableRecipient(messenger)
{
    [ObservableProperty]
    private string? name;

    [RelayCommand]
    private async Task SaveAsync()
    {
        logger.LogInformation("Saving {Name}", Name);
        await files.SaveAsync(Name!);
    }
}

Why constructor injection beats a service locator:

- Dependencies are explicit and visible at the call site

- Unit tests inject fakes/mocks directly

- The DI container validates the dependency graph at startup

- Missing registrations throw immediately, not at first use

---

Lifetimes

| Lifetime | Method | Typical use in XAML apps |

|----------|--------|--------------------------|

| Singleton | `AddSingleton<T>` | Shell/main-window VM, settings, file/HTTP services, the shared `IMessenger`, app-wide caches |

| Transient | `AddTransient<T>` | Per-page or per-document ViewModels (a fresh instance every resolve) |

| Scoped | `AddScoped<T>` | Rarely needed in client apps; useful with explicit `IServi