.Net Maui Understanding Dependency Injection In Maui Complete Guide

What is Dependency Injection?

Dependency Injection is a design pattern where an object or method receives other objects or methods (its dependencies) as parameters rather than creating them itself. In .NET MAUI, the built-in DI container (Microsoft.Extensions.DependencyInjection) is used to manage these dependencies.

Key Benefits of Dependency Injection

1. Decoupling: Objects are decoupled from their dependencies, allowing changes to be made independently.
2. Testability: Easier to write unit tests since dependencies can be easily mocked.
3. Maintainability: Simplifies maintaining and updating application architecture by making dependencies explicit.
4. Flexibility: Facilitates the substitution of dependencies with different implementations at runtime.

Setting Up Dependency Injection in .NET MAUI

At the core of DI setup in MAUI is the MauiAppBuilder. Here’s how you can set up DI:

• Create Services Collection: Use MauiAppBuilder to add services to the DI container.
• Add Transient, Singleton or Scoped Services: Define how long the instance of each service will live.

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        });

    // Register Services
    builder.Services.AddSingleton<IMyService, MyService>();
    builder.Services.AddTransient<IMyTransientService, MyTransientService>();

    return builder.Build();
}

Service Lifetimes in .NET MAUI

Understanding service lifetimes is critical for efficiently managing resources and ensuring that instances are created and disposed correctly:

1. Singleton: There is only one instance throughout the application lifecycle. Use this for services that do not hold any state.

   • Example: Logger services.

   builder.Services.AddSingleton<IMyService, MyService>();
   

2. Scoped: A new instance is created for every scope (typically per request in web apps, but can also be per user, session, etc., depending on your app). Within a view model, scoped services are usually per-view-model.

   • Example: User-specific settings or contexts.

   builder.Services.AddScoped<IMyScopedService, MyScopedService>();
   

3. Transient: A new instance is created every time the dependency is injected. This is useful for non-shared resources.

   • Example: Commands or operations that do not need to persist state.

   builder.Services.AddTransient<IMyTransientService, MyTransientService>();
   

Resolving Dependencies

Dependencies are resolved using constructors or property injection, though constructor injection is preferred in .NET MAUI due to its simplicity and clarity.

Constructor Injection

Pass dependencies as constructor parameters:

public class MainPageViewModel
{
    private readonly IMyService _myService;

    public MainPageViewModel(IMyService myService)
    {
        _myService = myService;
    }

    public void DoSomething()
    {
        _myService.SomeMethod();
    }
}

This approach keeps the view model's dependencies explicit and easier to manage.

Property Injection

Less common in .NET MAUI but can be useful when dealing with optional dependencies:

public class MainPageViewModel
{
    [ActivatorUtilitiesConstructor]
    public MainPageViewModel() {}

    public IMyService MyService { get; set; }

    public void DoSomething()
    {
        MyService?.SomeMethod();
    }
}

However, be wary that property injection can lead to less obvious and tighter coupling if not managed properly.

DI with MVVM Pattern

.NET MAUI often uses the Model-View-ViewModel (MVVM) pattern, where resolving dependencies plays a significant role. The .NET MAUI framework provides built-in support for DI with MVVM.

1. ViewModel Registration: ViewModels can be registered like any other service:

   builder.Services.AddTransient<MainPageViewModel>();
   

2. View Binding: Views can bind to ViewModels through BindingContext, which can be automatically set via the DI container:

   public MainPage()
   {
       InitializeComponent();
       BindingContext = MauiProgram.Current.Services.GetService<MainPageViewModel>();
   }
   

   Alternatively, consider using Maui.Controls.Extensions.Hosting for automatic binding, which reduces boilerplate:

   builder.Services.AddTransient<MainPage>();
   builder.Services.AddTransient<MainPageViewModel>();
   builder.UseMauiHosting()
          .ConfigureServices(services =>
           {
               services.AddTransient<IViewFor<MainPageViewModel>, MainPage>();
           })
          .ConfigureMauiHandlers(handlers =>
           {
               handlers.AddHandler(typeof(IViewFor<>), typeof(ViewHandler));
           });
   

Using the IServiceProvider

The .NET MAUI DI container implements IServiceProvider, allowing you to access services anytime within the application:

var myService = MauiProgram.Current.Services.GetService<IMyService>();

However, be cautious about using the service provider directly in your application logic. It makes code harder to test and understand.

Example

Here's a simple example to illustrate DI in a .NET MAUI MVVM application:

Interfaces and Services

public interface IMyService
{
    string GetData();
}

public class MyService : IMyService
{
    public string GetData() => "Hello from MyService!";
}

ViewModel

public class MainPageViewModel
{
    private readonly IMyService _myService;

    public string DisplayData { get; set; }

    public MainPageViewModel(IMyService myService)
    {
        _myService = myService;
        DisplayData = _myService.GetData();
    }
}

AppBuilder Setup

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        });

    // Register Services
    builder.Services.AddSingleton<IMyService, MyService>();

    // Register ViewModel
    builder.Services.AddTransient<MainPageViewModel>();

    // Register View and Bind ViewModel
    builder.Services.AddTransient<IViewFor<MainPageViewModel>, MainPage>();

    return builder.Build();
}

Main Page XAML

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.MainPage"
             xmlns:viewmodel="clr-namespace:MyMauiApp.ViewModel">
    <ContentPage.BindingContext>
        <viewmodel:MainPageViewModel/>
    </ContentPage.BindingContext>
    <StackLayout>
        <Label Text="{Binding DisplayData}"
               VerticalOptions="CenterAndExpand" 
               HorizontalOptions="CenterAndExpand"/>
    </StackLayout>
</ContentPage>

Conclusion

Dependency Injection in .NET MAUI provides a robust framework for building modular, maintainable, and testable applications. By leveraging the MauiAppBuilder to register services with appropriate lifetimes and using constructor injection for view models, developers can create applications that are easier to understand, scale, and modify.