Dot.Blog

C#, XAML, WinUI, WPF, Android, MAUI, IoT, IA, ChatGPT, Prompt Engineering

L'injection de Dépendances (DI) sous MAUI

MAUI intègre de façon unifiée l’injection de dépendances déjà à l’œuvre sous ASP.NET Core. En passant des Xamarin.Forms à MAUI il ne faut pas louper ce virage !

Le moteur d'injection intégré à MAUI

Comme vous le savez, .NET MAUI a évolué à partir des Xamarin.Forms en offrant une meilleure expérience de développement et de meilleures performances. Mais pas de boni ont été ajouté au passage, certains plus marquants ou voyants que d’autres comme l'ajout d’un moteur d'injection de dépendances totalement intégré ne nécessitant plus l’utilisation de bibliothèques externes.

Dans cet article nous verrons à quel point il est facile d'utiliser l'injection de dépendances dans une application .NET MAUI en s’appuyant sur un exemple simplifié mais fonctionnel.

Qu'est-ce que l'injection de dépendance ?

D’abord il y a le mot dépendance qui implique un lien, une connaissance entre deux partis le tout doublé d’une contrainte, la fameuse dépendance. Ici les différents tiers sont généralement des objets (des instances de classes). On parle donc d’une configuration particulière du code d’une application dont certains objets nécessitent pour leur fonctionnement d’accéder à des instances généralement d’autres classes. L'injection de dépendances est simplement une façon pour un objet-client de recevoir la référence d'autres objets-services dont il dépend pour fonctionner. Ici, « l’injecteur » désigne la méthode ou le code qui transmet l'objet-service à l'objet-client. L'injection de dépendance est une version particulière du pattern Inversion de Contrôle (IOC). Ici, la classe (son instance) du service d’injection injectera des dépendances dans un objet lors de l'exécution.

J’ai déjà présenté les concepts dans de nombreux articles ou livres exposant MVVM car ce pattern implique depuis déjà longtemps un découplage fort qui dépasse le cadre code/IHM pour s’intéresser à tout ce qui fait une App. Le lecteur intéressé pour éventuellement lire l’article suivant : https://www.e-naxos.com/Blog/post/MVVM-Service-Factory-IoC-injection-de-dependances-oui-mais-pourquoi-.aspx 

Avantages de l’Injection de Dépendances

Le principal avantage de l'injection de dépendances est qu'elle réduit le couplage entre les classes et leurs dépendances. J’en reviens à ce que je disais une ligne plus haut… Le concept peut-être le plus important qui s’est imposé au-delà du pattern MVVM ou ses semblables (MVU, MVC…) c’est celui du « découplage fort ». Toute forme de dépendance doit être pourchassée et éradiquée et être remplacée par des mécanismes plus souples.

Le code devient alors  plus facilement réutilisable, testable et maintenable puisque nous n'avons pas besoin de savoir et de maintenir comment les dépendances sont implémentées.

Cela rend aussi plus flexible l'accès des objets aux services.

Exemple d’utilisation de l’Injection de Dépendance dans MAUI

Partons d’une situation ultra simple : une App avec une page qui possède un Label.

La page (Mainpage.xaml) ressemblera alors à ceci :

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="DependencyInjectionInMAUI.MainPage">
<Label VerticalTextAlignment="Center" HorizontalTextAlignment="Center" Text="{Binding LabelText}"/>
</ContentPage>
Et son ViewModel (ViewModel.cs) sera le suivant :
namespace DependencyInjectionInMAUI
{
  public class ViewModel
  {
     public string LabelText { get; set; } = "Hello World";
  }
}

Lions la propriété LabelText au texte Label à l' aide de l'injection de dépendances en suivant ces étapes :

Étape 1 : Ouvrez le  fichier MauiProgram.cs . Ensuite, ajoutez-y une référence Microsoft.Extensions.DependencyInjection pour accéder aux méthodes d'extension du service.

Étape 2 : Ajoutez ensuite le service singleton d'injection de dépendances pour la MainPage et son ViewModel.

using Microsoft.Maui;
using Microsoft.Maui.Hosting;
using Microsoft.Maui.Controls.Compatibility;
using Microsoft.Maui.Controls.Hosting;
using Microsoft.Extensions.DependencyInjection;namespace DependencyInjectionInMAUI
{
  public static class MauiProgram
  {
    public static MauiApp CreateMauiApp()
    {
      var builder = MauiApp.CreateBuilder();
      builder
      .UseMauiApp<App>()
      .ConfigureFonts(fonts =>
      {
        fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
      });builder.Services.AddSingleton<MainPage>();builder.Services.AddSingleton<ViewModel>();
      return builder.Build();
    }
  }
}

Étape 3 : Après avoir ajouté les services nécessaires comme indiqué à l'étape 2, vous pouvez accéder directement à ces objets dans les constructeurs de classe souhaités. Par conséquent, on peut maintenant accéder aux objets de service MainPage et ViewModel dans les fichiers App.xaml.cs et MainPage.xaml.cs respectivement en ajoutant des arguments dans les constructeurs de ces classes. C’est le principe de l’injection de dépendances dans les constructeurs (qui est une des utilisations de l’injection de dépendances mais pas la seule).

Ainsi Appxaml.cs deviendra :

namespace DependencyInjectionInMAUI
{
  public partial class App : Application
  {
    public App(MainPage mainPage)
    {
      InitializeComponent();MainPage = new MainPage();
    }
  }
}

Et MainPage.xaml.cs :

namespace DependencyInjectionInMAUI
{
  public partial class MainPage : ContentPage
  {
    public MainPage( ViewModel viewModel)
    {
      InitializeComponent();
    }}
}

Étape 4 : Maintenant, récupérez les objets de service à partir de l'argument du constructeur et affectez-les aux objets clients comme dans le code suivant :

Appxaml.cs

namespace DependencyInjectionInMAUI
{
  public partial class App : Application
  {
    public App(MainPage mainPage)
    {
      InitializeComponent();MainPage = mainPage;
    }
  }
}

MainPage.xaml.cs

namespace DependencyInjectionInMAUI
{
  public partial class MainPage : ContentPage
  {
    public MainPage( ViewModel viewModel)
    {
      InitializeComponent();
      this.BindingContext = viewModel;
    }}
}

Il ne reste plus qu’à lancer l’App et vérifier que tout fonctionne correctement !

Conclusion

L’injection de dépendances notamment dans les constructeurs simplifie la vie du développeur et rend le code meilleur, plus facile à tester, à maintenir, et à coder aussi. Le principe n’est pas très compliqué, il faut s’entraîner un peu mais cela en vaut la peine ! Ceux qui pratique ASP.NET Core connaissent déjà le principe et ceux qui utilisent des toolbox MVVM le savent aussi depuis longtemps, notamment grâce aux nombreux articles et livres gratuits de Dot.Blog !

L’autre avancée qu’il faut saluer est la volonté clairement affichée et mise en œuvre de Microsoft d’unifier tous les .NET à travers Core mais aussi la façon de développer tous les types d’application. Ainsi le Builder d’une application MAUI, tout comme son injection de dépendance étaient déjà dans ASP.NET Core au départ, et aujourd’hui c’est toute la plateforme MAUI qui utilise l’exact même principe. Cette homogénéité n’est pas seulement source de simplification et de bogues en moins, c’est aussi le plaisir de travailler dans un environnement unifié où ce qu’on apprend ici est valable là-bas. Dans un monde cross-plateforme c’est un vrai plus.

Stay Tuned !


Faites des heureux, PARTAGEZ l'article !

Ajouter un commentaire