ArcGIS Pro SDK for .NET Add-In Module - Is there a way to implement Dependency Injection using Microsoft.Extensions.Hosting HostBuilder?

diegom_geoowl

I’ve been trying to implement proper Dependency Injection using Microsoft.Extensions.DependecyInjection and Microsoft.Extensions.Hosting but I keep running into this error whenever I try build my HostBuilder  “Could not load file or assembly 'System.Diagnostics.DiagnosticSource, Version=7.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'. The system cannot find the file specified”. I would appreciate any help, thank you. 

DevinCarlson1

For those wondering how to get this to work. You need to evaluate what version of .NET your version of Pro is targeted for, and what assemblies may conflict with ones you are trying to load in your Add-In. If you want to use Microsoft.Extensions.* libraries, or some System.* ones provided via NuGet, you need to make sure those versions don't conflict with assemblies already loaded by Pro. You should also be aware of any libraries you include that may try to dynamically scan for assemblies, which typically use the AppDomain.CurrentDomain instead of your Add-In's assembly--and account for that by registering an event handler to point to your Add-In's assembly during the Add-In module initialization phase.

 

1. The first step is determine the .NET version you should target. For example, if you are on ArcGIS Pro 3.5 which targets .NET 8. Go to the installation folder and examine the `System.*` and `Microsoft.*` assemblies and hover over them to get the tooltip and examine the file version. This will clue you into what versions from NuGet will be compatible to use which will not confuse the assembly loader. Also be cognizant of the rest of the assemblies in the installation location, if any other of your dependencies may use them, like `DocumentFormat.OpenXml` which at this time uses a 2.X version, some modern libraries may require versions >= 3.x which will cause an assembly load error if you try to use a newer version.

2. Once you have determined the .NET version and assembly constraints, you can add in the required packages to your project. `Microsoft.Extensions.Hosting.8.0.1` should implicitly add pretty much everything you need for a powerful use of DI in your Add-In.

3. To effectively use DI in a per-module fashion for an Add-In, you can start by creating an abstract base class called `ServiceProviderModule<TModule>` which will contain everything you need to bootstrap your assembly and DI during the Module initialization. The following class will preload your Add-In assembly and expose a method to be implemented, `ConfigureServices` where you will register services, logging, configuration etc when your module inherits the ServiceProviderModule. Below the abstract module class is the `ServiceHost<TModule>` which contains and builds an `IHost` that the `ServiceProviderModule<TModule>` pulls services from via a static property.

ServiceProviderModule<TModule>

using System;
using System.IO;
using System.Reflection;
using Microsoft.Extensions.Hosting;
using Module = ArcGIS.Desktop.Framework.Contracts.Module;

namespace Example.DependencyInjection.Module;

public abstract class ServiceProviderModule<TModule> : Module
{
    protected sealed override bool Initialize()
    {
        AppDomain.CurrentDomain.AssemblyResolve += ResolveExecutingAssembly;
        ServiceHost<TMarker>.Configure(ConfigureServices);
        return OnInitialize();
    }

    public static IServiceProvider Services => ServiceHost<TModule>.Services;
    protected abstract void ConfigureServices(HostApplicationBuilder builder);
    protected virtual bool OnInitialize() => base.Initialize();
    private Assembly? ResolveExecutingAssembly(object? sender, ResolveEventArgs args)
    {
        var directory = Path.GetDirectoryName(typeof(TModule).Assembly.Location);
        var name = $"{new AssemblyName(args.Name).Name}.dll";
        var path = Path.Combine(directory, name);
        return File.Exists(path) ? Assembly.LoadFrom(path) : null;
    }
    protected override bool CanUnload()
    {
        ServiceHost<TModule>.Shutdown();
        return base.CanUnload();
    }
}

 

ServiceHost<TModule>

The ServiceHost<TModule> also takes care of setting the base path of the HostApplicationBuilder.Configuration base path to the true location of the add-in assembly loaded. Without this, the default path is usually somewhere in a temp folder in AppData where your `appsettings.json` files will not be. Include any `appsettings.json` files as content and they will be packaged into the `esriAddInX` file when you build it.

using System;
using System.IO;
using System.Threading;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;

namespace Example.DependencyInjection.Module;

internal static class ServiceHost<TModule>
{
    private static Action<HostApplicationBuilder>? _configure;
    private static readonly Lazy<IHost> _host = new (BuildHost, LazyThreadSafetyMode.ExecutionAndPublication);

    public static void Configure(Action<HostApplicationBuilder> configure)
    {
        if (_host.IsValueCreated)
            throw new InvalidOperationException("Host already built. Configure must be called before first service is resolved.");
        _configure = configure;
    }
    
    public static IServiceProvider Services => _host.Value.Services;
    public static void Shutdown() => _host.Value.Dispose();
    
    private static IHost BuildHost()
    {
        var builder = Host.CreateApplicationBuilder();
        builder.Configuration.SetBasePath(Path.GetDirectoryName(typeof(TModule).Assembly.Location));
        _configure?.Invoke(builder);
        return builder.Build();
    }
}

 

ExampleModule

The following ExampleModule inherits from ServiceProviderModule<TModule> and supplies its own type as the assembly type. Using Serilog is shown as a "gotcha" I ran into when using some Sinks which can get resolved via assembly scanning if loading the Serilog configuration from an IConfiguration source. Just register your services in the ConfigureServices method and do all of your wiring up here. ConfigureServices is called when the Module initializes as seen in the ServiceProviderModule<TModule> code. Beware of any async code that could deadlock the UI thread during initialization.

• User secrets and non-production appsettings.json file loaded into the IConfiguration
• Serilog is configured using the IConfiguration and set up for ILogger<T> use

using ArcGIS.Desktop.Framework;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Serilog;

namespace Example.DependencyInjection.Module
{
    internal class ExampleModule : ServiceProviderModule<ExampleModule>
    {
        private static ExampleModule? _this = null;
        public static ExampleModule Current => _this ??= (ExampleModule)FrameworkApplication.FindModule("Example.DependencyInjection.Module_Module");
        protected override void ConfigureServices(HostApplicationBuilder builder)
        {
            if (!builder.Environment.IsProduction())
            {
                builder.Configuration.AddUserSecrets("8f807625-e49b-4df5-bcc3-fcf6b2027964");
                builder.Configuration.AddJsonFile($"./appsettings.{builder.Environment.EnvironmentName}.json");
            }
            else
            {
                builder.Configuration.AddJsonFile($"./appsettings.json");
            }

            // Dyanmic assembly loading still needs a little help with Serilog. Thankfully you can specify the assembly loading context here
            var context = DependencyContext.Load(typeof(ExampleModule).Assembly);
            var options = new ConfigurationReaderOptions(context); 
            var logger = Log.Logger = new LoggerConfiguration()
                .ReadFrom.Configuration(builder.Configuration, options)
                .CreateLogger();

            builder.Logging.ClearProviders();
            builder.Logging.AddSerilog(logger);
        }

        /// <summary>
        /// Called by Framework when ArcGIS Pro is closing
        /// </summary>
        /// <returns>False to prevent Pro from closing, otherwise True</returns>
        protected override bool CanUnload()
        {
            base.CanUnload();
            return true;
        }
        

    }
}

 

Now that module initialization is out of the way, you can work on adding DI to your components in your Add-In. A simple example is a button which calls a logger to log something. If you want your components to be testable you should follow the same DI principals of exposing a public constructor with arguments you want to use for dependency injection. While ArcGIS Pro requires public parameterless constructors for it to initialize components, public constructors can call other constructors internally on the class which contain the service resolution logic.

ExampleButton

In the following Button example, we inject two services, the IConfiguration and an ILogger<ExampleButton> which are registered to private readonly fields as best practice. Then, on the OnClick method, the logger writes an information method, and we display a MessageBox which contains a value provided by the IConfiguration as just a simple service example.

using ArcGIS.Desktop.Framework.Contracts;
using ArcGIS.Desktop.Framework.Dialogs;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Example.DependencyInjection.Module;

public class ExampleButton : Button
{
    private readonly IConfiguration _configuration;
    private readonly ILogger<ExampleButton> _logger;

    public ExampleButton() : this(
        ExampleModule.Services.GetService<IConfiguration>(),
        ExampleModule.Services.GetService<ILogger<ExampleButton>>())
    {
        
    }

    public ExampleButton(IConfiguration configuration, ILogger<ExampleButton> logger)
    {
        _configuration = configuration;
        _logger = logger;
    }

    protected override void OnClick()
    {
        _logger.LogInformation("This came from a dependency injected logger");
        MessageBox.Show($"Hello! I got this from the configuration: {_configuration.GetSection("Example")?.Get<string>()}");
    }
}

 

You can go one step further, and if you need to resolve any services registered as transient services. Just inject `IServiceScopeFactory` as an injected service and create a service scope to pull out a transient or scoped service.