.NET MAUI Understanding Dependency Injection in MAUI Step by step Implementation and Top 10 Questions and Answers
 Last Update: April 01, 2025      17 mins read      Difficulty-Level: beginner

Understanding Dependency Injection in .NET MAUI

Dependency Injection (DI) is a powerful design pattern used in software development to achieve loose coupling between classes. By using DI, you can manage object lifetimes, dependencies, and provide greater testability in your applications. .NET MAUI, Microsoft’s modern, single-codebase framework for building native user interfaces for Windows, macOS, iOS, and Android, integrates DI natively, making it easier to build maintainable and scalable applications. This article will explain DI in detail and highlight important information related to its usage in .NET MAUI.

What is Dependency Injection?

Dependency Injection is a design pattern where classes receive the dependencies they need from an external source rather than creating them internally. This external source is known as the dependency injector. The benefits of using DI include:

  • Testability: Easier to test because components are decoupled from their dependencies.
  • Maintainability: Changes in one part of the application do not necessarily affect other parts as they are loosely coupled.
  • Scalability: Simplifies adding new features or changing existing ones with minimal impact on other parts of the application.

Key Concepts in Dependency Injection

  1. Service: The object that provides functionality.
  2. Consumer: The object that uses the service.
  3. Lifetime: The scope of how long a service is created and kept alive.
  4. Registration: The process of configuring services and their lifetimes with the DI container.
  5. Resolution: The process of providing a service when requested by a consumer.

Configuring Dependency Injection in .NET MAUI

In .NET MAUI, the DI container is configured in the MauiProgram.cs file. Here’s how you can set it up:

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

    builder.Services.AddTransient<IMyService, MyService>();
    builder.Services.AddTransient<IAnotherService, AnotherService>();
    builder.Services.AddSingleton<ISingletonService, SingletonService>();

    return builder.Build();
}

In the above code:

  • IMyService and MyService are an interface and its implementation, respectively.
  • AddTransient<IMyService, MyService>(); registers MyService as a transient service.
  • AddSingleton<ISingletonService, SingletonService>(); registers SingletonService as a singleton service.

Service Lifetimes in .NET MAUI

Understanding service lifetimes is crucial for managing your application’s memory and performance. .NET MAUI provides three main service lifetimes:

  1. Transient: A new instance of the service is created each time it is requested.
    • Use cases: Lightweight services with no state or state that changes frequently.
  2. Scoped: A new instance of the service is created once per request. In a web app, it means one instance per HTTP request.
    • Use cases: Services that maintain state for the duration of a single operation.
  3. Singleton: A single instance of the service is created and shared across all requests.
    • Use cases: Services that maintain state that should persist throughout the application’s lifecycle.

Important Information on DI in .NET MAUI

  1. Registering Services:

    • Use AddSingleton<T>() for services that should have a single instance for the lifetime of the application.
    • Use AddScoped<T>() for services that should have a unique instance per scope, typically per request in web applications.
    • Use AddTransient<T>() for services that should be created each time they are requested.

  2. Constructor Injection:

    • Most common, DI services are usually injected via constructors. For example: 
      public class MyPage : ContentPage
{
    private IMyService _myService;

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

  3. Property Injection:

    • Less common but still possible, typically used for optional dependencies. However, it is generally discouraged as it can lead to harder-to-test code.

  4. Method Injection:

    • Rarely used, method injection involves passing a dependency as a parameter of a method.

  5. Testing with DI:

    • DI simplifies testing by allowing the substitution of dependencies with mocks or fakes. For example: 
      var mockService = new Mock<IMyService>();
var page = new MyPage(mockService.Object);

  6. Built-in Services:

    • .NET MAUI comes with several built-in services that can be injected, such as IConnectivity, IDeviceDisplay, and IMainThread.

  7. Registering Multiple Implementations:

    • You can register multiple implementations of the same interfaces using different keys or factories: 
      builder.Services.AddTransient<IMyService, MyService>();
builder.Services.AddTransient<IMyService, AnotherMyService>("AnotherImplementation");

  8. Conditional Registration:

    • Conditional registration can be used to register services only under certain conditions: 
      if (someCondition)
{
  builder.Services.AddTransient<IMyService, MyService>();
}
else
{
  builder.Services.AddTransient<IMyService, AnotherService>();
}

  9. Performance Considerations:

    • Be mindful of the lifetimes you choose to avoid memory leaks or performance degradation, especially with singleton services.

  10. Advanced Features:

    • .NET MAUI supports advanced DI features like named instances, factories, and decorators, which can be leveraged for more complex scenarios.

Conclusion

Dependency Injection is a fundamental aspect of building maintainable and scalable applications in .NET MAUI. By understanding and effectively using DI, developers can achieve loose coupling, improve testability, and manage dependencies efficiently. Whether you are building a simple app or a large enterprise application, mastering DI will greatly enhance your development experience and application quality.

Understanding Dependency Injection in .NET MAUI: Examples, Setting Route, Running Application, and Data Flow

Dependency Injection (DI) is a design pattern that is essential for managing dependencies between components in modern applications. In .NET MAUI, DI helps in creating modular and easy-to-test applications. Here, we'll walk through setting up DI in a .NET MAUI application, define routes for navigation, run the application, and examine how data flows through the system.

Prerequisites

  • Basic understanding of .NET MAUI.
  • C# programming.
  • Visual Studio (2022 or later) with the .NET MAUI workload installed.

Step-by-Step Guide

  1. Create a New .NET MAUI Application

    Open Visual Studio and create a new project. Select the ".NET MAUI App (Preview)" template and name your project, for example, DiMauiApp.

  2. Set Up Dependency Injection in MauiProgram.cs

    The MauiProgram class is where you configure services for your application. Here's how to register services using DI.

    using Microsoft.Extensions.DependencyInjection;
using DiMauiApp.Services;

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

            // Register your services here
            builder.Services.AddTransient<IDataService, DataService>();

            return builder.Build();
        }
    }
}

  3. Create an Interface and Implementation

    Define an interface IDataService and its implementation DataService.

    // IDataService.cs
namespace DiMauiApp.Services
{
    public interface IDataService
    {
        string GetData();
    }
}

// DataService.cs
namespace DiMauiApp.Services
{
    public class DataService : IDataService
    {
        public string GetData()
        {
            return "Hello from Dependency Injection!";
        }
    }
}

  4. Consume the Service in a ViewModel

    Create a ViewModel that consumes the IDataService and use it to fetch data.

    // MainPageViewModel.cs
using DiMauiApp.Services;
using System.ComponentModel;

namespace DiMauiApp
{
    public class MainPageViewModel : INotifyPropertyChanged
    {
        private readonly IDataService _dataService;
        private string _data;

        public string Data
        {
            get => _data;
            set
            {
                _data = value;
                OnPropertyChanged(nameof(Data));
            }
        }

        public MainPageViewModel(IDataService dataService)
        {
            _dataService = dataService;
            Data = _dataService.GetData();
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

  5. Bind the ViewModel to the View

    Modify the MainPage to bind to the MainPageViewModel and display the data fetched from the service.

    <!-- MainPage.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="DiMauiApp.MainPage"
             xmlns:local="clr-namespace:DiMauiApp"
             Title="Dependency Injection Example">

    <ContentPage.BindingContext>
        <local:MainPageViewModel />
    </ContentPage.BindingContext>

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Label 
                Text="{Binding Data}"
                FontSize="Medium"
                HorizontalTextAlignment="Center" />

        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

  6. Register and Initialize the ViewModel Using DI

    Update MauiProgram.cs to register MainPageViewModel.

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

    // Register your services
    builder.Services.AddTransient<IDataService, DataService>();
    builder.Services.AddTransient<MainPageViewModel>();

    return builder.Build();
}

    Modify MainPage.xaml.cs to inject the ViewModel.

    using DiMauiApp.ViewModels;

namespace DiMauiApp
{
    public partial class MainPage : ContentPage
    {
        private readonly MainPageViewModel _viewModel;

        public MainPage(MainPageViewModel viewModel)
        {
            InitializeComponent();

            _viewModel = viewModel;
            BindingContext = _viewModel;
        }
    }
}

  7. Set Up Navigation Routes and Navigate Between Pages

    Add a second page to demonstrate navigation.

    // SecondPage.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="DiMauiApp.SecondPage"
             Title="Second Page">

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Label 
                Text="Welcome to Second Page"
                FontSize="Medium"
                HorizontalTextAlignment="Center" />

        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

    Modify App.xaml.cs to register routes.

    using Microsoft.Maui.Controls;

namespace DiMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new NavigationPage(new MainPage());
        }

        protected override void OnStart()
        {
            Routing.RegisterRoute("SecondPage", typeof(SecondPage));

            base.OnStart();
        }
    }
}

    Add a button in MainPage.xaml to navigate to the second page.

    <!-- MainPage.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="DiMauiApp.MainPage"
             xmlns:local="clr-namespace:DiMauiApp"
             Title="Dependency Injection Example">

    <ContentPage.BindingContext>
        <local:MainPageViewModel />
    </ContentPage.BindingContext>

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Label 
                Text="{Binding Data}"
                FontSize="Medium"
                HorizontalTextAlignment="Center" />

            <Button 
                Text="Go to Second Page"
                Clicked="OnNavigateToSecondPage" 
                HorizontalOptions="Center" />

        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

    Handle the button click in MainPage.xaml.cs.

    using Microsoft.Maui.Controls;
using DiMauiApp.ViewModels;

namespace DiMauiApp
{
    public partial class MainPage : ContentPage
    {
        private readonly MainPageViewModel _viewModel;

        public MainPage(MainPageViewModel viewModel)
        {
            InitializeComponent();

            _viewModel = viewModel;
            BindingContext = _viewModel;
        }

        private async void OnNavigateToSecondPage(object sender, EventArgs e)
        {
            await Shell.Current.GoToAsync("SecondPage");
        }
    }
}

  8. Run the Application

    Press F5 or click the "Start" button in Visual Studio to run the application. You should see the label displaying text from DataService and a button to navigate to the second page.

Data Flow Explanation

  • Service Registration: MauiProgram.cs registers DataService and MainPageViewModel as transient services.
  • View Binding: MainPage.xaml binds MainPageViewModel as its BindingContext.
  • Dependency Injection: When MainPage is instantiated, MainPageViewModel is injected with DataService.
  • Data Fetching: MainPageViewModel calls GetData from DataService and stores it in the Data property.
  • UI Update: The UI updates automatically when Data changes, thanks to INotifyPropertyChanged.
  • Navigation: Clicking the button triggers navigation to SecondPage using routes defined in App.xaml.cs.

By following these steps, you can understand how Dependency Injection works in .NET MAUI, manage services efficiently, and implement navigation between pages in your application. This foundational knowledge can help you build scalable and maintainable MAUI applications.

Certainly! Here are the top 10 questions and answers regarding Dependency Injection (DI) in .NET Multi-platform App UI (MAUI):

1. What is Dependency Injection (DI) in .NET MAUI, and why is it important?

Answer: Dependency Injection is a design pattern used to achieve Inversion of Control (IoC) where components specify their dependencies rather than creating the instances of their dependencies. In .NET MAUI, DI helps in managing dependencies within the application efficiently. This pattern facilitates better testability, modularity, and maintainability of the code. By using DI, developers can separate the construction and usage of the objects, making the codebase more adaptable and easier to manage.

2. How does .NET MAUI support Dependency Injection out-of-the-box?

Answer: .NET MAUI leverages the built-in dependency injection mechanism provided by Microsoft.Extensions.DependencyInjection. This allows developers to define services and their lifetimes in the MauiProgram.cs file, making them available throughout the application. The DI container handles the instantiation and resolution of these dependencies, ensuring that services are correctly injected wherever needed across different parts of the application.

3. What are the different lifetimes available for services in the DI container in .NET MAUI?

Answer: In .NET MAUI, the dependency injection container supports three main service lifetimes:

  • Singleton: A single instance of the service is created and reused throughout the application lifecycle.
  • Scoped: A single instance of the service is created per request or scope. In the context of MAUI, it means a single instance per IMauiContext which typically aligns with the lifetime of the page or service.
  • Transient: A new instance of the service is created each time it is requested.

4. How do you register services with different lifetimes in .NET MAUI?

Answer: Services can be registered in the MauiProgram.cs file using the IServiceCollection interface within the CreateBuilder method. Here's how you can register services with different lifetimes:

public static MauiApp CreateMauiApp()
{
    MauiAppBuilder builder = MauiApp.CreateBuilder();
    builder.Services.AddSingleton<IMyService, MyServiceSingleton>();
    builder.Services.AddScoped<IMyService, MyServiceScoped>();
    builder.Services.AddTransient<IMyService, MyServiceTransient>();

    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        });

    return builder.Build();
}

5. How can you inject dependencies into a ViewModel in .NET MAUI?

Answer: Dependencies can be injected into ViewModels via the constructor using DI. The DI container will automatically resolve the dependencies. For example:

public class MainViewModel
{
    private readonly IMyService _myService;
    public MainViewModel(IMyService myService)
    {
        _myService = myService;
    }

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

You must ensure that the ViewModel is also registered with the DI container so that it can receive its dependencies.

6. Can you inject dependencies into Pages or other UI components in .NET MAUI?

Answer: Yes, dependencies can be injected into Pages or other UI components, including custom controls, using the constructor approach. However, this is not as common as injecting into ViewModels because Pages are typically resolved by the framework rather than being manually instantiated. To enable constructor injection for Pages, you can use the ActivatorUtilities.CreateInstance method:

var myPage = ActivatorUtilities.CreateInstance<IMyPage>(ServiceProvider);

Alternatively, you can use the DependencyProperty or BindableProperty pattern to manually set the dependencies, but this is less preferred than DI.

7. What are the best practices for using Dependency Injection in .NET MAUI?

Answer: Best practices for using DI in .NET MAUI include:

  • Keep services simple and focused: Each service should have a single responsibility.
  • Use interfaces for services: This abstracts the implementation and makes the code more testable.
  • Avoid circular dependencies: Circular dependencies can lead to complex code and runtime issues. Design your services in a way that avoids circular references.
  • Register dependencies appropriately: Use the correct lifetime for each service based on its required use.
  • Minimize service discovery: Rely on constructor injection to get dependencies rather than using service locators, which can lead to tight coupling.

8. How does .NET MAUI handle DI when dealing with platform-specific code?

Answer: .NET MAUI abstracts platform-specific code through interfaces, and the DI container is used to inject platform-specific implementations. You can define platform-specific services by using conditional compilation or by using platform-specific project files to register different implementations of a service for different platforms. For example:

#if WINDOWS
builder.Services.AddSingleton<IPlatformService, WindowsPlatformService>();
#elif ANDROID
builder.Services.AddSingleton<IPlatformService, AndroidPlatformService>();
#elif IOS
builder.Services.AddSingleton<IPlatformService, iOSPlatformService>();
#endif

9. Can you use Dependency Injection to manage state in .NET MAUI applications?

Answer: Yes, DI can be used to manage state in .NET MAUI applications by registering stateful services and injecting them where needed. For example, you can use a Singleton service to manage global state across the application:

public class AppState
{
    public string Username { get; set; }
}

// Register in MauiProgram.cs
builder.Services.AddSingleton<AppState>();

Inject AppState into the ViewModel or Page where it's needed:

public class MainViewModel
{
    private readonly AppState _appState;
    public MainViewModel(AppState appState)
    {
        _appState = appState;
    }

    public void SetUsername(string username)
    {
        _appState.Username = username;
    }
}

10. Are there any common pitfalls to avoid when using Dependency Injection in .NET MAUI?

Answer: Common pitfalls to avoid when using DI in .NET MAUI include:

  • Overusing DI: Not everything needs to be injected. Simple objects or primitives can be passed directly.
  • Using DI for everything: Avoid over-relying on DI for all dependencies. It can lead to overly complex design patterns.
  • Ignoring service lifetimes: Misunderstanding and misconfiguring service lifetimes can lead to memory leaks or incorrect behavior.
  • Over-scoping: Scoping a service too tightly can lead to excessive memory usage, as services will be created and disposed of more frequently than necessary.
  • Ignoring the cost of DI: While DI provides many benefits, it can introduce some overhead. Be mindful of performance considerations, especially in critical sections of your app.

By understanding and applying these practices, you can effectively use Dependency Injection in .NET MAUI to build robust, maintainable, and scalable applications.