Support ASP.NET Core 3.0

[whizkidwwe1217]

There are lots of changes in ASP.NET Core 3.0 and breaks StructureMap.Microsoft.DependencyInjection. The new framework dropped the support for configuring third-party DI containers via ConfigureServices, which, returns an IServiceProvider class. Now, developers who use StructureMap.MicrosoftDependencyInjection must use the other method of wiring up the DI container. That is, by using the StructureMap.AspNetCore extensions. However, the current version is still using the IWebHostBuilder and it needs to be migrated to IHostBuilder to support ASP.NET 3.0. The code below shows the current implementation of the ServiceCollectionExtensions and WebHostBuilderExtensions. The former extension class need not to return an IServiceCollection since it's not supported in ASP.NET Core 3 and instead, return a void. Meanwhile, the WebHostBuildExtensions class must call the UseServiceProviderFactory before calling the ConfigureServices method.

Current solution:

public static class ServiceCollectionExtensions
{
        public static IServiceCollection AddStructureMap(this IServiceCollection services)
        {
            return AddStructureMap(services, registry: null);
        }

        public static IServiceCollection AddStructureMap(this IServiceCollection services, Registry registry)
        {
            return services.AddSingleton<IServiceProviderFactory<Registry>>(new StructureMapServiceProviderFactory(registry));
        }
}

public static class WebHostBuilderExtensions
{
        public static IWebHostBuilder UseStructureMap(this IWebHostBuilder builder)
        {
            return UseStructureMap(builder, registry: null);
        }

        public static IWebHostBuilder UseStructureMap(this IWebHostBuilder builder, Registry registry)
        {
            return builder.ConfigureServices(services => services.AddStructureMap(registry));
        }
}

Proposed solution:

public static class ServiceCollectionExtensions
{
        public static void AddStructureMap(this IServiceCollection services)
        {
            AddStructureMap(services, registry: null);
        }

        public static void AddStructureMap(this IServiceCollection services, Registry registry)
        {
            services.AddSingleton<IServiceProviderFactory<Registry>>(new StructureMapServiceProviderFactory(registry));
        }
}

public static class HostBuilderExtensions
{
    public static IHostBuilder UseStructureMap(this IHostBuilder builder)
    {
        return UseStructureMap(builder, registry: null);
    }

    public static IHostBuilder UseStructureMap(this IHostBuilder builder, Registry registry)
    {
        return builder
           .UseServiceProviderFactory<Registry>(new StructureMapServiceProviderFactory(registry))
           .ConfigureServices(services => services.AddStructureMap(registry));
    }
}

[brandonmartinez]

Was a PR created for this? Is there going to be?

[khellang]

We'll gladly accept a PR to support ASP.NET Core 3

[wallymathieu]

It looks as if it works as long as you use some of the same patterns as a .net core 2.1 webapp. Use the old format for program.cs.

[juanjoDiaz]

Any progress on this?

[wallymathieu]

Best bet is probably to migrate over Lamar instead since StructureMap is sunsetted @juanjoDiaz .

[dustinsoftware]

For those running into this issue, here's what I did to get this to work with the new HostBuilder on netcoreapp3.1.

Some of this was taken from Autofac's docs.

Program.cs:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseServiceProviderFactory(new StructureMapContainerBuilderFactory())
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
}

public void ConfigureContainer(Container builder)
{
    builder.Configure(config =>
    {
        // Your services here
        config.AddRegistry(new MyRegistry());
    });
}

The registry:

public class MyRegistry : Registry
{
    public MyRegistry()
    {
        For<Something>().Singleton().Use<Something>();
    }
}

StructureMapContainerBuilderFactory.cs

public class StructureMapContainerBuilderFactory : IServiceProviderFactory<Container>
{
    private IServiceCollection _services;

    public Container CreateBuilder(IServiceCollection services)
    {
        _services = services;
        return new Container();
    }

    public IServiceProvider CreateServiceProvider(Container builder)
    {
        builder.Configure(config =>
        {
            config.Populate(_services);
        });

        return builder.GetInstance<IServiceProvider>();
    }
}

[khellang]

@dustinsoftware The library already provides a StructureMapServiceProviderFactory, (but it works with Registry, not Container), so you don't have to write that yourself. The only thing you should have to do, is provide your own extension method:

public static class HostBuilderExtensions
{
    public static IHostBuilder UseStructureMap(this IHostBuilder builder)
    {
        return UseStructureMap(builder, registry: null);
    }

    public static IHostBuilder UseStructureMap(this IHostBuilder builder, Registry registry)
    {
        return builder.UseServiceProviderFactory(new StructureMapServiceProviderFactory(registry))
    }
}

Then call it:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseStructureMap(new MyRegistry()/* optional */);
        .ConfigureWebHostDefaults(web => web.UseStartup<Startup>());

You can choose to pass a registry instance from outside (as shown in this example), or you can configure it inside the Startup class. In that case you need to change it to Registry:

public void ConfigureContainer(Registry registry)
{
    // Your services here
}

[devigo]

Perhaps this PR will allow us to use this library with .NET Core 3.*. I'm using the solution provided by @khellang for hosted services in console applications (.NET Core 2.1).