How can I resolve a service that I registered with the builder.Services inside of a ViewModel?

Question

Summary: I am hoping to use MAUI's builder.Services to resolve services in ViewModels, but I don't understand how to do so.

I could create my own IServiceProvider, but I am hoping to avoid the needed boilerplate code, so instead I seek a "standard MAUI" solution.

I added the following line to MauiProgram.CreateMauiApp():

builder.Services.AddSingleton<IAlertService, AlertService>();

And the corresponding declarations (in other files):

public interface IAlertService
{
    // ----- async calls (use with "await") -----
    Task ShowAlertAsync(string title, string message, string cancel = "OK");
    Task<bool> ShowConfirmationAsync(string title, string message, string accept = "Yes", string cancel = "No");
}

internal class AlertService : IAlertService
{
    // ----- async calls (use with "await") -----

    public Task ShowAlertAsync(string title, string message, string cancel = "OK")
    {
        return Application.Current.MainPage.DisplayAlert(title, message, cancel);
    }

    public Task<bool> ShowConfirmationAsync(string title, string message, string accept = "Yes", string cancel = "No")
    {
        return Application.Current.MainPage.DisplayAlert(title, message, accept, cancel);
    }
}

Then in my BaseViewModel class:

internal class BaseViewModel
{
    protected static IAlertService AlertSvc = ??? GetService (aka Resolve) ???
    
    public static void Test1()
    {
        Task.Run(async () =>
            await AlertSvc.ShowAlertAsync("Some Title", "Some Message"));
    }
}

Question: How fill AlertSvc with the service registered in MauiProgram?

CREDIT: Based on a suggested "DialogService" in some SO discussion or MAUI issue. Sorry, I've lost track of the original.

Answer 1

All the dependencies will be provided through the IServiceProvider implementation that is part of .NET MAUI. Luckily, the IServiceProvider itself is added to the dependency injection container as well, so you can do the following.

Add what you need to your dependency injection container in the MauiProgram.cs:

builder.Services.AddSingleton<IStringService, StringService>();
builder.Services.AddTransient<FooPage>();

For completeness, my StringService looks like this:

public interface IStringService
{
    string GetString();
}

public class StringService : IStringService
{
    public string GetString()
    {
        return "string";
    }
}

Then in your FooPage, which can also be your view model or anything of course, add a constructor like this:

public FooPage(IServiceProvider provider)
{
    InitializeComponent();

    var str = provider.GetService<IStringService>().GetString();
}

Here you can see that you resolve the service manually through the IServiceProvider and you can call upon that. Note that you'll want to add some error handling here to see if the service actually can be resolved.

Answer 2

It is possible to access service provider without using DI injection via parameter of constructor (as in other answers):

myvar = Application.Current.Handler.MauiContext.Services.GetService<SomeType>();

I’m not aware of any reason to do this instead of using DI, but I mention it for completeness. Its also informative to see this access to MauiContext.

Answer 3

If you cannot (or do not want to) use the automatic constructor injection of MAUI Shell, you can still leverage the IServiceProvider instance which is part of the MauiApp class.

Instead of storing a reference to the implementation of the IServiceProvider in the App class, which introduces other dependency issues when writing unit tests for ViewModels and such, you can just create a static ServiceHelper class:

public static class ServiceHelper
{
    public static IServiceProvider Services { get; private set; }

    public static void Initialize(IServiceProvider serviceProvider) => 
        Services = serviceProvider;

    public static T GetService<T>() => Services.GetService<T>();
}

Then, you initialize this ServiceHelper in the MauiProgram.cs file after calling the Build() method:

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();

    // ...

    builder.Services.AddSingleton<IAlertService, AlertService>();

    var app = builder.Build();

    //we must initialize our service helper before using it
    ServiceHelper.Initialize(app.Services);

    return app;
}

Finally, you can resolve any dependencies in your classes, such as your ViewModels as follows:

private IAlertService _alertService;

public class MyViewModel()
{
    _alertService = ServiceHelper.GetService<IAlertService>();
}

This can then also be used in unit tests, where you can simply provide a fake or mock implementation to the ServiceHelper, e.g.:

using Moq;

namespace MyTests;

[TestFixture]
public class MyViewModelTests
{
    [Setup]
    public void Setup()
    {
        var alertServiceMock = new Mock<IAlertService>();
        var serviceProviderMock = new Mock<IServiceProvider>();
        serviceProviderMock
            .Setup(sp => sp.GetService<IAlertService>())
            .Returns(alertServiceMock.Object);

        ServiceHelper.Initialize(serviceProviderMock.Object);
    }

    // write tests here...
}

I just also published a blog article about this topic, which goes into more detail.

Answer 4

This should be a part of the MAUI App.xaml.cs file generated by Visual Studio (as on April 2023). A property for "Services" should be already added there, like we have in ASP.NET Core. I had to do this as suggested by Gerald and Steve

public partial class App : Application
{
    // cached for later use
    public IServiceProvider Services { get; private set; }

    public App(IServiceProvider provider)
    {
        InitializeComponent();

        Services = provider;

        MainPage = new AppShell();
    }
}