Dependency injection in WPF project with .net core

DI WPF-C#.md

Dependency injection in WPF project with .net core

Delete StartupUri="MainWindow.xaml" from App.xaml

Install packages :

Microsoft.Extensions.Configuration.Json
Microsoft.Extensions.DependencyInjection
Microsoft.Extensions.Options.ConfigurationExtensions

Add the file appsettings.json in the root of the project to use it for configuration.

Override OnStartup method in App.Xaml.Cs class :

public IServiceProvider ServiceProvider { get; private set; }

public IConfiguration Configuration { get; private set; }

protected override void OnStartup(StartupEventArgs e)
{
    var builder = new ConfigurationBuilder()
     .SetBasePath(Directory.GetCurrentDirectory())
     .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);

    Configuration = builder.Build();

    var serviceCollection = new ServiceCollection();
    ConfigureServices(serviceCollection);

    ServiceProvider = serviceCollection.BuildServiceProvider();

    var mainWindow = ServiceProvider.GetRequiredService<MainWindow>();
    mainWindow.Show();
}

private void ConfigureServices(IServiceCollection services)
{
    services.Configure<AppSettings>(Configuration.GetSection(nameof(AppSettings)));

    services.AddTransient(typeof(MainWindow));
}

Nice ..

How do i then fetch my services in various usercontrols ? :)

eg, if the service isn't injected via constructor, then how do you fetch it ?

i'm guessing something a like: ServiceProvider.Current.GetInstance();

but ServiceProvider isn't globally available ?

so, here's what i've done so far:

make the ServiceProvider Static on App:

    public static IServiceProvider ServiceProvider { get; private set; }

Access it via App class:

    App.ServiceProvider.GetService<...>

havent tested if it works :D

so, here's what i've done so far:

make the ServiceProvider Static on App:

    public static IServiceProvider ServiceProvider { get; private set; }

Access it via App class:

    App.ServiceProvider.GetService<...>

havent tested if it works :D

That is a way to do it, but you're shooting yourself in the foot a little bit if you're doing anything serious. That's because instead of abstracting dependencies, you now have a dependency on that service provider.

It's a lot nicer when your actual UI parts like user controls don't need to know about services at all, rather they provide a rendering of the underlying data (or viewmodel if you're fancy). It's that underlying little bean that needs to know how to talk to services. But the actual wpf parts can remain blissfully unconcerned.

If the MainWindow constructor requires all of the services and factories needed to pass down to all the data parts, it can stay pretty clean.

Typically when you're doing it this way, though, the only parameter for MainWindow would be an IMainWindowViewModel or something similar and in the implementation of that is where it goes hog wild with dependency requirements.

Hi again (sorry for the long delay)

The problem with constructor injection in WPF is that usercontrol hierachy and how one would normally write XAML, wont use the serviceprovider to fetch usercontrols.

eg

<VehicleManager> 
    <VehicleList>
       <ItemsControl>
             <Vehicle>

Vehicles are generated on the fly by the XAML binding and wont be requested from the ServiceProvider.
Usually controls are spawned from the UI rather than from the codebehind...

So i dont know how useful DI is for WPF...

I am struggling to pass the viewmodel to the view as a parameter constructor, while still being able to design my UI in xaml.
I randomly came across this discussion, is there any possibility that you found an elegant solution?

I am struggling to pass the viewmodel to the view as a parameter constructor, while still being able to design my UI in xaml. I randomly came across this discussion, is there any possibility that you found an elegant solution?

If your viewmodel only exists once: use Singleton and simply reference it in your usercontrol

if your viewmodel exists pr usercontrol / window, instantiate a new one and pass it to the constructor or instantiate it in the constructor .... or do everything like MVC and let the codebehind be the Viewmodel ... usually the easiest option.

ViewModels only make sense if they aggregate several UserControls

btw.. I've given up on using DI for WPF .. it makes no sense