Getting Started
NServiceBus
Transports
Persistence
ServiceInsight
ServicePulse
ServiceControl
Monitoring
Previews
Samples

ASP.NET Core Dependency Injection Integration

NuGet Package: NServiceBus (8-pre)
This page targets a pre-release version. Pre-releases are subject to change and samples are not guaranteed to be fully functional.

ASP.NET Core has an integrated dependency injection (DI) feature. When hosting NServiceBus endpoints inside an ASP.NET Core app, it may be necessary to share components registered for DI between ASP.NET components and NServiceBus message handlers. Use the NServiceBus.Extensions.Hosting package to host an endpoint as part of an ASP.NET Core application.

Configuring an endpoint to use built-in DI

Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddSingleton<MyService>();
    })
    .UseNServiceBus(c =>
    {
        var endpointConfiguration = new EndpointConfiguration("Sample.Core");
        endpointConfiguration.UseTransport<LearningTransport>();
        return endpointConfiguration;
    })
    .ConfigureWebHostDefaults(webBuilder => webBuilder.UseStartup<Startup>());

When the sample is run, a web application is started. All web requests received will trigger a message send operation:

applicationBuilder.Run(
    handler: context =>
    {
        if (context.Request.Path != "/")
        {
            // only handle requests at the root
            return Task.CompletedTask;
        }
        var applicationServices = applicationBuilder.ApplicationServices;
        var endpointInstance = applicationServices.GetService<IMessageSession>();
        var myMessage = new MyMessage();

        return Task.WhenAll(
            endpointInstance.SendLocal(myMessage),
            context.Response.WriteAsync("Message sent"));
    });

Message handlers will have dependencies injected at runtime by the configured Inversion of Control container:

public class MyHandler :
    IHandleMessages<MyMessage>
{
    MyService myService;

    public MyHandler(MyService myService)
    {
        this.myService = myService;
    }

    public Task Handle(MyMessage message, IMessageHandlerContext context)
    {
        myService.WriteHello();
        return Task.CompletedTask;
    }
}

Configuring to use shared DI with Autofac

It is also possible to configure ASP.NET Core to use a specific container and still share components between ASP.NET and NServiceBus message handlers. This sample demonstrates how to do this with Autofac using the Autofac.Extensions.DependencyInjection package

This can also be done using other DI libraries.

First, ASP.NET Core is instructed to use a custom container:

Host.CreateDefaultBuilder(args)
    .UseServiceProviderFactory(new AutofacServiceProviderFactory())

Then, Startup can use Autofac natively to configures services:

public void ConfigureServices(IServiceCollection services)
{
    services.AddLogging(loggingBuilder => loggingBuilder.AddConsole());
}

public void ConfigureContainer(ContainerBuilder containerBuilder)
{
    containerBuilder.RegisterType<MyService>().SingleInstance();
}

The ConfigureServices method is called by .NET Core at application startup time to register additional services. The ConfigureContainer method registers the components in the container using the container's native APIs.

Related Articles


Last modified