public void ConfigureServices(IServiceCollection services)
{
    services.AddMassTransit(busBuilder =>
    {
        // ...
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMassTransit(busBuilder =>
    {
        busBuilder.UseInMemory("connection-name-1", hostBuilder => 
        {
            hostBuilder.UseServiceScope();

            hostBuilder.AddConfigurator(configureBus =>
            {
                configureBus.UseRetry(r => r.Immediate(3));
            });

            // ...
        });

        busBuilder.UseRabbitMq("connection-name-2", "127.0.0.1", "/vhost", hostBuilder => 
        {
            hostBuilder.UseCredentials("guest", "guest");

            // ...
        });

        busBuilder.UseActiveMq("connection-name-3", "127.0.0.1", hostBuilder => 
        {
            hostBuilder.UseSsl();
            hostBuilder.UseCredentials("guest", "guest");

            // ...
        });

        busBuilder.UseAmazonSqs("connection-name-4", hostBuilder => 
        {
            hostBuilder.UseRegion(RegionEndpoint.USEast1);
            hostBuilder.UseCredentials(new EnvironmentVariablesAWSCredentials());

            // ...
        });

        busBuilder.UseAzureServiceBus("connection-name-5", new Uri("sb://namespace.servicebus.windows.net/scope"), hostBuilder =>
        {
            hostBuilder.UseServiceScope();

            hostBuilder.UseTokenProvider(TokenProvider.CreateSimpleWebTokenProvider("token-test"));

            hostBuilder.AddConfigurator(configureBus =>
            {
                configureBus.SelectBasicTier();
            });
        });

        busBuilder.UseHttp("connection-name-6", new Uri("http://127.0.0.1:8080"), hostBuilder =>
        {
            hostBuilder.UseServiceScope();
            hostBuilder.UseMethod(HttpMethod.Post);
            hostBuilder.AddReceiveEndpoint("example-queue-6", endpointBuilder =>
            {
                endpointBuilder.AddConsumer<ExampleConsumer>();
            });
        });

    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMassTransit(busBuilder =>
    {
        busBuilder.UseInMemory("connection-name-1", hostBuilder => 
        {
            // ...

            hostBuilder.AddReceiveEndpoint("example-queue-1", endpointBuilder =>
            {
                endpointBuilder.AddConfigurator(configureEndpoint =>
                {
                    configureEndpoint.UseRetry(r => r.Immediate(3));
                });

                // ...
            });
        });
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMassTransit(busBuilder =>
    {
        busBuilder.UseInMemory("connection-name-1", hostBuilder => 
        {
            // ...

            hostBuilder.AddReceiveEndpoint("example-queue-1", endpointBuilder =>
            {
                endpointBuilder.AddConsumer<ExampleConsumer>(configureConsumer =>
                {
                    configureConsumer.UseRateLimit(10);

                    // ...
                });
            });
        });
    });
}

public async Task Run(IServiceProvider serviceProvider)
{
    var busManager = serviceProvider.GetRequiredService<IBusManager>();

    // start all bus instances
    await busManager.StartAsync().ConfigureAwait(false);

    // get a reference to a named bus instance
    // and publish a message
    IBus bus = busManager.GetBus("connection-name-1");
    await bus.Publish(/* ... */).ConfigureAwait(false);

    // ...

    // stop all bus instances
    await busManager.StopAsync().ConfigureAwait(false);
}

public static class Program
{
    private static void Main(string[] args)
    {
        // use the new generic host from ASP.NET Core
        // see for more info: https://github.com/aspnet/Hosting/issues/1163
        new HostBuilder()
            .ConfigureHostConfiguration(config => config.AddEnvironmentVariables())
            .ConfigureAppConfiguration((context, builder) => ConfigureAppConfiguration(context, builder, args))
            .ConfigureServices(ConfigureServices)
            .Build()
            .Run();
    }

    private static void ConfigureAppConfiguration(HostBuilderContext context, IConfigurationBuilder configurationBuilder, string[] args)
    {
        var environmentName = context.HostingEnvironment.EnvironmentName;

        configurationBuilder.AddJsonFile("appsettings.json", optional: true);
        configurationBuilder.AddJsonFile($"appsettings.{environmentName}.json", optional: true);

        configurationBuilder.AddCommandLine(args);
    }

    private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
    {
        services.AddTransient<IWidgetService, WidgetService>();
        // add other DI services...

        // optionally use configuration for any settings
        var configuration = context.Configuration;

        // the following adds IBusManager which is also an IHostedService that is started/stopped by HostBuilder
        services.AddMassTransit(busBuilder =>
        {
            // configure RabbitMQ
            busBuilder.UseRabbitMq(configuration.GetSection("MassTransit:RabbitMq"), hostBuilder =>
            {
                // use scopes for all downstream filters and consumers
                // i.e. per-request lifetime
                hostBuilder.UseServiceScope();

                // example adding an optional configurator to the bus
                // using IRabbitMqBusFactoryConfigurator
                hostBuilder.AddConfigurator(configureBus =>
                {
                    configureBus.UseRetry(r => r.Immediate(1));
                });

                // example adding a receive endpoint to the bus
                hostBuilder.AddReceiveEndpoint("example-queue-1", endpointBuilder =>
                {
                    // example adding an optional configurator to the receive endpoint
                    // using IRabbitMqReceiveEndpointConfigurator
                    endpointBuilder.AddConfigurator(configureEndpoint =>
                    {
                        configureEndpoint.UseRetry(r => r.Immediate(3));
                    });

                    // example adding a consumer to the receive endpoint
                    endpointBuilder.AddConsumer<ExampleConsumer>(configureConsumer =>
                    {
                        // example adding an optional configurator to the consumer
                        // using IConsumerConfigurator<TConsumer>
                        configureConsumer.UseRetry(r => r.Immediate(3));
                    });
                });
            });

            // adding more bus instances...
            busBuilder.UseInMemory("connection-name-2", hostBuilder =>
            {
                hostBuilder.UseServiceScope();
                hostBuilder.AddReceiveEndpoint("example-queue-2", endpointBuilder =>
                {
                    endpointBuilder.AddConsumer<ExampleConsumer>();
                });
            });
        });
    }
}

public static class Program
{
    private static readonly string EnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Development";

    private static void Main()
    {
        var configuration = LoadConfiguration();
        using (var services = CreateServiceProvider(configuration))
        {
            Run(services);
        }
    }

    private static IConfiguration LoadConfiguration()
    {
        var configBuilder = new ConfigurationBuilder();

        configBuilder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
        configBuilder.AddJsonFile($"appsettings.{EnvironmentName}.json", optional: true, reloadOnChange: true);

        configBuilder.AddEnvironmentVariables();

        // WARNING: Do not add the command line arguments to the configuration
        // builder. The arguments used by Topshelf are not compatible with the
        // .NET Core command line provider.
        // configBuilder.AddCommandLine(args);

        var configuration = configBuilder.Build();
        return configuration;
    }

    private static ServiceProvider CreateServiceProvider(IConfiguration configuration)
    {
        var services = new ServiceCollection();

        ConfigureServices(configuration, services);

        return services.BuildServiceProvider();
    }

    private static void ConfigureServices(IConfiguration configuration, IServiceCollection services)
    {
        services.AddSingleton(configuration);

        // configure logging
        services.AddLogging(builder =>
        {
            builder.AddConfiguration(configuration.GetSection("Logging"));

            builder.AddNLog();
            builder.AddDebug();
        });

        // the following adds IBusManager which is also an IHostedService that is started/stopped down below
        services.AddMassTransit(busBuilder =>
        {
            // configure RabbitMQ
            busBuilder.UseRabbitMq(configuration.GetSection("MassTransit:RabbitMq"), hostBuilder =>
            {
                hostBuilder.UseServiceScope();

                hostBuilder.AddReceiveEndpoint("example-queue-1", endpointBuilder =>
                {
                    endpointBuilder.AddConsumer<ExampleConsumer>();
                });
            });
        });
    }

    private static void Run(IServiceProvider serviceProvider)
    {
        ExtensionsLogger.Use(); // MassTransit
        NLogLogWriterFactory.Use(); // Topshelf

        var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
        var logger = loggerFactory.CreateLogger(typeof(Program));

        logger.LogInformation("Program Starting");
        logger.LogInformation("Environment={0}", EnvironmentName);
        logger.LogInformation(Assembly.GetExecutingAssembly().FullName);

        // configure and run the topshelf service
        HostFactory.Run(hostConfigurator =>
        {
            // log exception details
            hostConfigurator.OnException(exception => logger.LogError(exception.ToString()));

            // configure the hosted service
            hostConfigurator.Service<IHostedService>(serviceConfigurator =>
            {
                serviceConfigurator.ConstructUsing(serviceProvider.GetRequiredService<IHostedService>);
                serviceConfigurator.WhenStarted(async host => await host.StartAsync(CancellationToken.None).ConfigureAwait(false));
                serviceConfigurator.WhenStopped(async host => await host.StopAsync(CancellationToken.None).ConfigureAwait(false));
            });

            // by default use a least privileged account
            hostConfigurator.RunAsNetworkService();

            // default the ServiceName, DisplayName, and Description from the entry assembly
            hostConfigurator.UseAssemblyInfoForServiceInfo();
        });

        logger.LogInformation("Program Exiting");
    }
}