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.
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;
}
}
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 :