Dependency Injection in .NET MAUI

Service Registration in MauiProgram.cs

builder.Services

inside

CreateMauiApp()

csharp

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder.UseMauiApp<App>();

    // Services
    builder.Services.AddSingleton<IDataService, DataService>();
    builder.Services.AddTransient<IApiClient, ApiClient>();

    // ViewModels
    builder.Services.AddTransient<MainViewModel>();
    builder.Services.AddTransient<DetailViewModel>();

    // Pages
    builder.Services.AddTransient<MainPage>();
    builder.Services.AddTransient<DetailPage>();

    return builder.Build();
}

Lifetime Guidance

Lifetime	Use When	Examples
`AddSingleton<T>`	Shared state, expensive to create, or app-wide config	Database connection, settings service, HttpClient factory
`AddTransient<T>`	Stateless, lightweight, or per-request usage	ViewModels, pages, API call wrappers
`AddScoped<T>`	Per-scope lifetime (rarely used in MAUI — no built-in scope per page)	Scoped unit-of-work in manually created scopes

Rule of thumb: Use
AddTransient
for ViewModels and Pages. Use
AddSingleton
for services that hold shared state or are expensive to construct. Avoid
AddScoped
unless you create and manage
IServiceScope
instances yourself.

Constructor Injection (Preferred)

Inject dependencies through the constructor. The DI container resolves them automatically when the type is itself resolved from the container:

csharp

public class MainViewModel
{
    private readonly IDataService _dataService;
    private readonly IApiClient _apiClient;

    public MainViewModel(IDataService dataService, IApiClient apiClient)
    {
        _dataService = dataService;
        _apiClient = apiClient;
    }
}

ViewModel → Page Pattern

BindingContext

csharp

public partial class MainPage : ContentPage
{
    public MainPage(MainViewModel viewModel)
    {
        InitializeComponent();
        BindingContext = viewModel;
    }
}

Automatic Resolution via Shell Navigation

When Pages are registered in the DI container and registered as Shell routes, Shell resolves them (and their dependencies) automatically:

csharp

// In MauiProgram.cs
builder.Services.AddTransient<DetailPage>();
builder.Services.AddTransient<DetailViewModel>();

// Route registration (AppShell.xaml.cs or startup)
Routing.RegisterRoute(nameof(DetailPage), typeof(DetailPage));

// Navigation — DI resolves DetailPage and its DetailViewModel
await Shell.Current.GoToAsync(nameof(DetailPage));

Explicit Resolution

When constructor injection is not available, resolve services explicitly:

csharp

// From any Element with a Handler
var service = this.Handler.MauiContext.Services.GetService<IDataService>();

IServiceProvider Injection

Inject

IServiceProvider

when you need to resolve services dynamically:

csharp

public class MyService
{
    private readonly IServiceProvider _serviceProvider;

    public MyService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public void DoWork()
    {
        var api = _serviceProvider.GetRequiredService<IApiClient>();
    }
}

Platform-Specific Service Registration

Use preprocessor directives to register platform-specific implementations:

csharp

// In MauiProgram.cs
#if ANDROID
builder.Services.AddSingleton<INotificationService, AndroidNotificationService>();
#elif IOS || MACCATALYST
builder.Services.AddSingleton<INotificationService, AppleNotificationService>();
#elif WINDOWS
builder.Services.AddSingleton<INotificationService, WindowsNotificationService>();
#endif

Interface-First Pattern for Testability

Define interfaces for services so implementations can be swapped in tests:

csharp

public interface IDataService
{
    Task<List<Item>> GetItemsAsync();
}

public class DataService : IDataService
{
    public async Task<List<Item>> GetItemsAsync() { /* ... */ }
}

// Register the interface → implementation mapping
builder.Services.AddSingleton<IDataService, DataService>();

In tests, substitute a mock without touching production code:

csharp

var services = new ServiceCollection();
services.AddSingleton<IDataService, FakeDataService>();

Gotcha: XAML Resource Parsing vs. DI Timing

XAML resources (styles, resource dictionaries in

App.xaml

) are parsed before the

App

class is fully resolved from the container. If a resource or converter needs a service, inject

IServiceProvider

into the

App

constructor and resolve what you need in

CreateWindow()

csharp

public partial class App : Application
{
    private readonly IServiceProvider _services;

    public App(IServiceProvider services)
    {
        _services = services;
        InitializeComponent(); // XAML resources parse here
    }

    protected override Window CreateWindow(IActivationState? activationState)
    {
        // Safe to resolve services here — container is fully built
        var mainPage = _services.GetRequiredService<MainPage>();
        return new Window(new AppShell());
    }
}

Quick Checklist

Register every Page and ViewModel you want injected in
```
MauiProgram.cs
```
.
Prefer constructor injection over service-locator calls.
Use
```
AddSingleton
```
only for truly shared or expensive services.
Use interfaces for any service you want to mock in tests.
Use
```
#if
```
directives for platform-specific implementations.
Resolve late-bound services in
```
CreateWindow()
```
, not during XAML parse.

maui-dependency-injection

NPX Install

Tags

SKILL.md Content

Dependency Injection in .NET MAUI

Service Registration in MauiProgram.cs

Lifetime Guidance

Constructor Injection (Preferred)

ViewModel → Page Pattern

Automatic Resolution via Shell Navigation

Explicit Resolution

IServiceProvider Injection

Platform-Specific Service Registration

Interface-First Pattern for Testability

Gotcha: XAML Resource Parsing vs. DI Timing

Quick Checklist