Aller au contenu

Injection de dépendances

Les ViewModels reçoivent leurs services par le constructeur ; un conteneur les assemble.

flowchart TB
  SC["ServiceCollection<br/>(enregistrement au démarrage)"] --> SP["ServiceProvider"]
  SP -- "GetRequiredService ClientsViewModel" --> VM["ClientsViewModel"]
  SP -- "le constructeur demande<br/>IClientService" --> CS["ClientServiceApi"]
  SP -- "qui demande HttpClient" --> H["HttpClient"]
  CS --> VM
  H --> CS

Vous demandez le ViewModel ; le conteneur crée toute la chaîne de dépendances.

dotnet add package Microsoft.Extensions.DependencyInjection

Déclarer les services

Services/IClientService.cs
public interface IClientService
{
    Task<IReadOnlyList<Client>> GetClientsAsync();
}

public class ClientServiceApi(HttpClient http) : IClientService
{
    public async Task<IReadOnlyList<Client>> GetClientsAsync()
        => await http.GetFromJsonAsync<List<Client>>("api/clients") ?? [];
}

ViewModel avec dépendances

public partial class ClientsViewModel(IClientService clients) : ObservableObject
{
    [ObservableProperty]
    public partial IReadOnlyList<Client> Liste { get; set; } = [];

    [RelayCommand]
    private async Task ChargerAsync() => Liste = await clients.GetClientsAsync();
}

Configurer le conteneur

App.axaml.cs
using Microsoft.Extensions.DependencyInjection;

public partial class App : Application
{
    public static IServiceProvider Services { get; private set; } = null!;

    public override void Initialize() => AvaloniaXamlLoader.Load(this);

    public override void OnFrameworkInitializationCompleted()
    {
        var services = new ServiceCollection();

        // Services
        services.AddSingleton(new HttpClient { BaseAddress = new Uri("https://api.exemple.fr/") });
        services.AddSingleton<IClientService, ClientServiceApi>();

        // ViewModels
        services.AddSingleton<MainViewModel>();
        services.AddTransient<ClientsViewModel>();

        Services = services.BuildServiceProvider();

        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
        {
            desktop.MainWindow = new MainWindow
            {
                DataContext = Services.GetRequiredService<MainViewModel>()
            };
        }

        base.OnFrameworkInitializationCompleted();
    }
}
Durée de vie Usage
AddSingleton une instance pour toute l'appli (services, ViewModel principal)
AddTransient nouvelle instance à chaque demande (ViewModels de pages)
AddScoped rarement utile en desktop

Créer des ViewModels à la demande

public partial class MainViewModel(IServiceProvider services) : ObservableObject
{
    [ObservableProperty]
    public partial ObservableObject? PageCourante { get; set; }

    [RelayCommand]
    private void OuvrirClients() => PageCourante = services.GetRequiredService<ClientsViewModel>();
}

Services liés à l'interface

Le ViewModel ne doit pas connaître Window. Exposez une abstraction :

public interface IDialogueService
{
    Task<string?> ChoisirFichierAsync();
}

public class DialogueService : IDialogueService
{
    public async Task<string?> ChoisirFichierAsync()
    {
        var desktop = (IClassicDesktopStyleApplicationLifetime)Application.Current!.ApplicationLifetime!;
        var storage = desktop.MainWindow!.StorageProvider;

        var fichiers = await storage.OpenFilePickerAsync(new FilePickerOpenOptions());
        return fichiers.Count > 0 ? fichiers[0].TryGetLocalPath() : null;
    }
}
services.AddSingleton<IDialogueService, DialogueService>();

Tester avec un faux service

flowchart LR
  subgraph App["Dans l'application"]
    VM1["ClientsViewModel"] --> R["ClientServiceApi<br/>(vrai réseau)"]
  end
  subgraph Test["Dans les tests"]
    VM2["ClientsViewModel"] --> F["FauxClients<br/>(données en dur)"]
  end
class FauxClients : IClientService
{
    public Task<IReadOnlyList<Client>> GetClientsAsync()
        => Task.FromResult<IReadOnlyList<Client>>([new Client { Nom = "Test" }]);
}

[Fact]
public async Task Charger_remplit_la_liste()
{
    var vm = new ClientsViewModel(new FauxClients());
    await vm.ChargerCommand.ExecuteAsync(null);
    Assert.Single(vm.Liste);
}

Hôte générique (configuration, logs)

Pour profiter de appsettings.json et ILogger :

dotnet add package Microsoft.Extensions.Hosting
var host = Host.CreateApplicationBuilder();
host.Services.AddSingleton<MainViewModel>();
host.Services.AddSingleton<IClientService, ClientServiceApi>();
Services = host.Build().Services;