Stashbox.Extensions.Hosting 4.5.0

There is a newer version of this package available.
See the version list below for details.
dotnet add package Stashbox.Extensions.Hosting --version 4.5.0                
NuGet\Install-Package Stashbox.Extensions.Hosting -Version 4.5.0                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Stashbox.Extensions.Hosting" Version="4.5.0" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Stashbox.Extensions.Hosting --version 4.5.0                
#r "nuget: Stashbox.Extensions.Hosting, 4.5.0"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Stashbox.Extensions.Hosting as a Cake Addin
#addin nuget:?package=Stashbox.Extensions.Hosting&version=4.5.0

// Install Stashbox.Extensions.Hosting as a Cake Tool
#tool nuget:?package=Stashbox.Extensions.Hosting&version=4.5.0                

stashbox-extensions-dependencyinjection

Appveyor build status GitHub Workflow Status Tests Sourcelink

This repository contains Stashbox integrations for ASP.NET Core, .NET Generic Host and simple ServiceCollection based applications.

Package Version
Stashbox.Extensions.Dependencyinjection NuGet Version
Stashbox.Extensions.Hosting NuGet Version
Stashbox.AspNetCore.Hosting NuGet Version
Stashbox.AspNetCore.Multitenant NuGet Version

Options turned on by default:

  • Automatic tracking and disposal of IDisposable and IAsyncDisposable services.
  • Lifetime validation for Developement environments, but can be extended to all environment types.

Table of Contents

ASP.NET Core

The following example shows how you can integrate Stashbox (with the Stashbox.Extensions.Hosting package) as the default IServiceProvider implementation into your ASP.NET Core application:

ASP.NET Core 5
public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(String[] args)
    {
        return Host.CreateDefaultBuilder(args)
            .UseStashbox(container => // Optional configuration options.
            {
                // This one enables the lifetime validation for production environments too.
                container.Configure(config => config.WithLifetimeValidation());
            })
            .ConfigureContainer<IStashboxContainer>((context, container) =>
            {
                // Execute a dependency tree validation.
                if (context.HostingEnvironment.IsDevelopment())
                    container.Validate();
            })
            .ConfigureWebHostDefaults(
                webBuilder => webBuilder
                    .UseStartup<Startup>());
    }
}

You can also use the ConfigureContainer() method in your Startup class to use further configuration options:


public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Your service configuration.
    }

    public void ConfigureContainer(IStashboxContainer container)
    {
        // Your container configuration.
        container.Configure(config => config.WithLifetimeValidation());
    }

    public void Configure(IApplicationBuilder app)
    {
        // Your application configuration.
    }
}
ASP.NET Core 6
var builder = WebApplication.CreateBuilder(args);

builder.Host.UseStashbox(container => // Optional configuration options.
{
    // This one enables the lifetime validation for production environments too.
    container.Configure(config => config.WithLifetimeValidation());
});

builder.Host.ConfigureContainer<IStashboxContainer>((context, container) =>
{
    // Execute a dependency tree validation.
    if (context.HostingEnvironment.IsDevelopment())
        container.Validate();
});

Controller / View activation

By default the ASP.NET Core framework uses the DefaultControllerActivator to instantiate controllers, but it uses the ServiceProvider only for instantiating their constructor dependencies. This behaviour could hide important errors Stashbox would throw in case of a misconfiguration, so it's recommended to let Stashbox activate your controllers and views.

You can enable this by adding the following options to your service configuration:

ASP.NET Core 5
public void ConfigureServices(IServiceCollection services)
{
    // For controllers only.
    services.AddControllers()
            .AddControllersAsServices();
    
    // For controllers and views.
    services.AddControllersWithViews()
            .AddControllersAsServices()
            .AddViewComponentsAsServices();
}
ASP.NET Core 6
// For controllers only.
builder.Services.AddControllers()
    .AddControllersAsServices();
    
// For controllers and views.
builder.Services.AddControllersWithViews()
    .AddControllersAsServices()
    .AddViewComponentsAsServices();

Multitenant

The Stashbox.AspNetCore.Multitenant package provides support for multitenant applications with a component called TenantDistributor. It's responsible for the following tasks:

  1. Create / maintain the application level Root Container. This container is used to hold the default service registrations for your application.
  2. Configure / maintain tenant specific containers. These containers are used to override the default services with tenant specific registrations.
  3. Tenant identification. Determines the tenant Id based on the current context. To achieve that, you have to provide an ITenantIdExtractor implementation.
// The type used to extract the current tenant identifier.
// This implementation shows how to extract the tenant id from a HTTP header.

public class HttpHeaderTenantIdExtractor : ITenantIdExtractor
{
    public Task<object> GetTenantIdAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue("TENANT-ID", out var value))
            return Task.FromResult<object>(null);

        return Task.FromResult<object>(value.First());
    }
}
ASP.NET Core 5
public static IHostBuilder CreateHostBuilder(String[] args)
{
    return Host.CreateDefaultBuilder(args)
        .UseStashboxMultitenant<HttpHeaderTenantIdExtractor>(
            distributor => // The tenant distributor configuration options.
        {
            // The default service registration, it registers into the root container.
            // It also could be registered into the default 
            // service collection through the ConfigureServices() api.
            distributor.Register<IDependency, DefaultDependency>();

            // Configure tenants.
            distributor.ConfigureTenant("TenantA", container => 
                // Register tenant specific service override
                container.Register<IDependency, TenantASpecificDependency>());

            distributor.ConfigureTenant("TenantB", container => 
                // Register tenant specific service override
                container.Register<IDependency, TenantBSpecificDependency>());
        })
        // The container parameter is the tenant distributor itself.
        // Calling its Validate() method will verify the root container and each tenant.
        .ConfigureContainer<IStashboxContainer>((context, container) => 
        {
            // Validate the root container and all tenants.
            if (context.HostingEnvironment.IsDevelopment())
                container.Validate();
        })
        .ConfigureWebHostDefaults(
            webBuilder => webBuilder
                .UseStartup<Startup>());
    }
ASP.NET Core 6
var builder = WebApplication.CreateBuilder(args);
builder.Host.UseStashboxMultitenant<HttpHeaderTenantIdExtractor>(
    distributor => // The tenant distributor configuration options.
{
    // The default service registration, it registers into the root container.
    // It also could be registered into the default 
    // service collection through the ConfigureServices() api.
    distributor.Register<IDependency, DefaultDependency>();

    // Configure tenants.
    distributor.ConfigureTenant("TenantA", container => 
        // Register tenant specific service override
        container.Register<IDependency, TenantASpecificDependency>());

    distributor.ConfigureTenant("TenantB", container => 
        // Register tenant specific service override
        container.Register<IDependency, TenantBSpecificDependency>());
});

// The container parameter is the tenant distributor itself.
// Calling its Validate() method will verify the root container and each tenant.
builder.Host.ConfigureContainer<IStashboxContainer>((context, container) =>
{
    // Validate the root container and all tenants.
    if (context.HostingEnvironment.IsDevelopment())
        container.Validate();
});

With this example setup, you can differentiate tenants in a per-request basis identified by a HTTP header, where every tenant gets their overridden services.

.NET Generic Host

The following example adds Stashbox (with the Stashbox.Extensions.Hosting package) as the default IServiceProvider implementation into your .NET Generic Host application:

public class Program
{
    public static async Task Main(string[] args)
    {
        var host = Host.CreateDefaultBuilder(args)
            .UseStashbox(container => // Optional configuration options.
            {
                // This one enables the lifetime validation for production environments too.
                container.Configure(config => config.WithLifetimeValidation());
            })
            .ConfigureContainer<IStashboxContainer>((context, container) =>
            {
                // Execute a dependency tree validation.
                if (context.HostingEnvironment.IsDevelopment())
                    container.Validate();
            })
            .ConfigureServices((context, services) =>
            {
                services.AddHostedService<Service>();
            }).Build();

        await host.RunAsync();
    }
}

ServiceCollection Based Applications

With the Stashbox.Extensions.Dependencyinjection package you can replace Microsoft's built-in dependency injection container with Stashbox. This package contains the core functionality used by the Stashbox.Extensions.Hosting, Stashbox.AspNetCore.Hosting and Stashbox.AspNetCore.Multitenant packages.

The following example shows how you can use this integration:

public class Program
{
    public static async Task Main(string[] args)
    {
        // Create the service collection.
        var services = new ServiceCollection();

        // Configure your service collection.
        services.AddLogging();
        services.AddOptions();

        // Add your services.
        services.AddScoped<IService, Service>();

        // Integrate Stashbox with the collection and grab your ServiceProvider.
        var serviceProvider = services.UseStashbox(container => // Optional configuration options.
        {
            container.Configure(config => config.WithLifetimeValidation());
        });

        // Start using the application.
        using (var scope = serviceProvider.CreateScope())
        {
            var service = scope.ServiceProvider.GetService<IService>();
            await service.DoSomethingAsync();
        }
    }
}

Or you can use your own StashboxContainer to integrate with the ServiceCollection:

public class Program
{
    public static async Task Main(string[] args)
    {
        // Create your container.
        var container = new StashboxContainer(config => // Optional configuration options.
        {
            config.WithLifetimeValidation();
        });

        // Create the service collection.
        var services = new ServiceCollection();

        // Configure your service collection.
        services.AddLogging();
        services.AddOptions();

        // Add your services.
        services.AddScoped<IService, Service>();

        // Or add them through Stashbox.
        container.RegisterScoped<IService, Service>();

        // Integrate Stashbox with the collection.
        services.UseStashbox(container);

        // Execute a dependency tree validation.
        container.Validate();

        // Start using the application.
        await using (var scope = container.BeginScope())
        {
            var service = scope.Resolve<IService>();
            await service.DoSomethingAsync();
        }
    }
}

Additional IServiceCollection Extensions

Most of Stashbox's service registration functionalities are available as extension methods of IServiceCollection.

  • Named service registration:

    class Service2 : IService2
    {
        private readonly IService service;
    
        public Service2(IService service) 
        {
            this.service = service;
        }
    }
    
    var services = new ServiceCollection();
    services.AddTransient<IService, Service>(); // Name-less registration.
    services.AddTransient<IService, AnotherService>("serviceName"); // Register dependency with name.
    services.AddTransient<IService2, Service2>(config => 
      // Inject the named service as dependency.
      config.WithDependencyBinding<IService>(
          "serviceName" // Name of the dependency.
      ));
    
  • Service configuration with Stashbox's Fluent Registration API:

    var services = new ServiceCollection();
    services.AddTransient<IService, Service>(config => 
      config.WithFactory<IDependency>(dependency => new Service(dependency)).AsImplementedTypes());
    
  • Service decoration:

    class ServiceDecorator : IService
    {
        private readonly IService decorated;
    
        public ServiceDecorator(IService service)
        {
            this.decorated = service;
        }
    }
    
    var services = new ServiceCollection();
    services.AddTransient<IService, Service>();
    services.Decorate<IService, ServiceDecorator>();
    
  • Assembly registration:

    var services = new ServiceCollection();
    services.ScanAssemblyOf<IService>(
      // Set a filter for which types should be excluded/included in the registration process.
      // In this case, only the publicly available types are selected from the assembly.
      type => type.IsPublic, 
      // The service type selector. Used to filter which interface or base types the implementation should be mapped to.
      // In this case, we are registering only by interfaces.
      (implementationType, serviceType) => serviceType.IsInterface,
      false, // Do not map services to themselves. E.g: Service -> Service.
      config =>
      {
          // Register IService instances as scoped.
          if (config.ServiceType == typeof(IService))
              config.WithScopedLifetime();
      }
    );
    
  • Composition root:

    class CompositionRoot : ICompositionRoot
    {
        public void Compose(IStashboxContainer container)
        {
            container.Register<IService, Service>();
        }
    }
    
    var services = new ServiceCollection();
    services.ComposeBy<CompositionRoot>();
    
    // Or let Stashbox find all composition roots in an assembly.
    services.ComposeAssembly(typeof(CompositionRoot).Assembly);
    
Product Compatible and additional computed target framework versions.
.NET net5.0 is compatible.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
.NET Core netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.1 is compatible. 
.NET Framework net461 is compatible.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
5.6.0 1,155 8/21/2024
5.5.4 959 7/26/2024
5.5.3 19,206 4/10/2024
5.5.2 1,926 4/8/2024
5.5.1 139 4/2/2024
5.5.0 2,826 12/15/2023
5.4.0 219 11/19/2023
5.3.0 1,531 6/21/2023
5.2.2 535 6/13/2023
5.2.1 211 6/9/2023
5.2.0 916 6/5/2023
5.1.2 196 6/2/2023
5.1.1 204 6/1/2023
5.1.0 202 5/31/2023
5.0.0 211 5/28/2023
4.6.2 548 3/29/2023
4.6.1 247 3/29/2023
4.6.0 29,898 2/28/2023
4.5.3 623 1/26/2023
4.5.2 337 1/26/2023
4.5.1 502 1/20/2023
4.5.0 1,087 12/19/2022
4.4.0 9,599 12/6/2022
4.3.2 375 11/29/2022
4.3.1 685 10/14/2022
4.3.0 559 10/12/2022
4.2.3 10,814 9/9/2022
4.2.2 1,365 6/2/2022
4.2.1 17,593 5/16/2022
4.2.0 644 5/3/2022
4.1.2 17,736 4/10/2022
4.1.1 9,343 3/12/2022
4.1.0 551 3/7/2022
4.0.1 11,478 2/10/2022
4.0.0 694 2/9/2022
3.2.1 963 1/30/2022
3.2.0 6,023 12/5/2021
3.1.1 392 11/22/2021
3.1.0 354 11/22/2021
3.0.0 524 11/22/2021
2.11.4 6,544 5/26/2021
2.11.3 979 3/16/2021
2.11.2 1,952 1/31/2021
2.11.1 7,405 11/16/2020
2.11.0 595 11/15/2020
2.10.1 526 11/5/2020
2.10.0 533 11/2/2020
2.9.9 502 11/2/2020
2.9.8 775 10/19/2020
2.9.7 506 10/16/2020
2.9.6 552 10/16/2020
2.9.5 544 10/14/2020
2.9.4 1,229 7/21/2020
2.9.3 4,045 7/9/2020
2.9.2 674 6/29/2020
2.9.1 841 6/22/2020
2.9.0 686 6/8/2020
2.8.6 1,349 1/15/2020
2.8.5 935 11/11/2019
2.8.4 639 10/4/2019
2.8.3 653 9/12/2019
2.8.1 1,108 9/11/2019
2.7.1 688 6/10/2019
2.6.8 1,028 3/21/2019
2.6.7 794 1/13/2019
2.6.5 788 12/27/2018
2.6.4 729 12/26/2018
2.6.3 868 10/24/2018
2.6.2 1,219 7/3/2018