Finbuckle MultiTenant

https://www.finbuckle.com/MultiTenant/Docs
Admin
Finbuckle MultiTenant is an open source multi-tenancy library for .NET that enables tenant...
Tokens:27,994
Snippets:192
Trust Score:7.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Finbuckle.MultiTenant.AspNetCore package

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Install the Finbuckle.MultiTenant.AspNetCore package for ASP.NET Core integration. This package depends on Finbuckle.MultiTenant and includes ASP.NET Core-specific strategies.

```bash
dotnet add package Finbuckle.MultiTenant.AspNetCore

```

--------------------------------

### Typical Configuration for ASP.NET Core with Finbuckle.MultiTenant

Source: https://www.finbuckle.com/multitenant/docs/ConfigurationAndUsage

A basic ASP.NET Core setup using AddMultiTenant with a host strategy and configuration store. This registers dependencies, adds middleware, and should be placed before other app services and middleware.

```csharp
using Finbuckle.MultiTenant;

var builder = WebApplication.CreateBuilder(args);

// ...add app services

// add MultiTenant services
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore();

var app = builder.Build();

// add the MultiTenant middleware
app.UseMultiTenant();

// ...add other middleware

app.Run();

```

--------------------------------

### Install Finbuckle.MultiTenant.AspNetCore package

Source: https://www.finbuckle.com/MultiTenant

Use this command to add the main Finbuckle.MultiTenant package to an ASP.NET Core application.

```dotnet-cli
dotnet add package Finbuckle.MultiTenant.AspNetCore
```

--------------------------------

### Configure WithPerTenantAuthentication() in ASP.NET Core

Source: https://www.finbuckle.com/multitenant/docs/Authentication

Shows the setup for using WithPerTenantAuthentication() after AddMultiTenant<TTenantInfo>(). Defines an AppTenantInfo class with properties for authentication options, then configures authentication and MultiTenant services. The code includes using statements and the full Program.cs setup.

```csharp
using Finbuckle.MultiTenant.Abstractions;
using Finbuckle.MultiTenant.AspNetCore.Extensions;
using Finbuckle.MultiTenant.Extensions;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;

public class AppTenantInfo : TenantInfo
{
    public string? ChallengeScheme { get; set; }
    public string? CookieLoginPath { get; set; }
    public string? CookieLogoutPath { get; set; }
    public string? CookieAccessDeniedPath { get; set; }
    public string? OpenIdConnectAuthority { get; set; }
    public string? OpenIdConnectClientId { get; set; }
    public string? OpenIdConnectClientSecret { get; set; }
    public string? JwtAuthority { get; set; }
}

var builder = WebApplication.CreateBuilder(args);

 // ...add app services

// add authentication services
builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
       .AddCookie()
       .AddOpenIdConnect();

// add MultiTenant services
builder.Services.AddMultiTenant<AppTenantInfo>()
       .WithRouteStrategy()
       .WithConfigurationStore()
       .WithPerTenantAuthentication();

var app = builder.Build();

// add the MultiTenant middleware
app.UseMultiTenant();

// ...add other middleware

app.Run();

```

--------------------------------

### Per-tenant options in controller

Source: https://www.finbuckle.com/multitenant/docs/Options

The same controller example but now options are specific to the current tenant when using per-tenant configuration.

```csharp
public class MyController : Controller
{
    private readonly MyOptions _myOptions;

    public MyController(IOptionsMonitor<MyOptions> optionsAccessor)
    {
        // _myOptions.Option1 and .Option2 will be specific to the current tenant.
        _myOptions = optionsAccessor.Value;
    }
}

```

--------------------------------

### Register MultiTenant services with AddMultiTenant

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Register MultiTenant services in Program.cs using AddMultiTenant<TTenantInfo> with at least one strategy and one store. This example uses WithHostStrategy() and WithConfigurationStore().

```csharp
using Finbuckle.MultiTenant;

var builder = WebApplication.CreateBuilder(args);

// ...add other app services

builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore();

var app = builder.Build();

```

--------------------------------

### Configure MultiTenant with host strategy and configuration store

Source: https://www.finbuckle.com/MultiTenant

This is the minimal ASP.NET Core setup that registers MultiTenant services, adds the middleware, and uses the request host (subdomain) for resolution and appsettings.json for storage. Must be called before authentication/authorization middleware.

```csharp
using Finbuckle.MultiTenant;

var builder = WebApplication.CreateBuilder(args);

// add app services...

// add MultiTenant services
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore();

var app = builder.Build();

// add the MultiTenant middleware
app.UseMultiTenant();

// add other middleware...

app.Run();
```

--------------------------------

### ShortCircuitWhen() with custom predicate and optional redirect

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Use the ShortCircuitWhen() extension on MultiTenantBuilder<TTenantInfo> for advanced short-circuiting based on a custom predicate. The first example halts when an obsolete strategy is used or tenant is not resolved; the second adds a redirect to a relative URI. The predicate receives the HttpContext and can inspect StrategyInfo and IsResolved.

```csharp
// Advanced short circuiting: if an obsolete strategy was used or when tenant not resolved.
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore()
    .ShortCircuitWhen(config =>
    {
        config.Predicate = context => context.StrategyInfo?.Strategy is IMyCustomObsoleteStrategy || !context.IsResolved;
    });

// Including a redirect.
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore()
    .ShortCircuitWhen(config =>
    {
        config.Predicate = context => context.StrategyInfo?.Strategy is IMyCustomObsoleteStrategy || !context.IsResolved;
        config.RedirectTo = new Uri("/tenant/notfound", UriKind.Relative);
    });

```

--------------------------------

### WithDelegateStrategy: Custom Tenant Resolution via Lambda

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Configure a delegate strategy that determines the tenant identifier per request. The first example uses a simple lambda returning "initech". The second uses a typed lambda with HttpContext, extracting the "tenant" query parameter; it runs only when the runtime context is assignable to HttpContext, otherwise falls through to the next strategy.

```csharp
// use custom logic to get the tenant identifier
builder.Services.AddMultiTenant<TenantInfo>()
    .WithDelegateStrategy(context => Task.FromResult<string?>("initech"))...

// or register with a typed lambda, HttpContext in this case; derived runtime types are also supported
builder.Services.AddMultiTenant<TenantInfo>()
    .WithDelegateStrategy<HttpContext, TenantInfo>(httpContext =>
    {
        var tenantIdentifier = httpContext.Request.Query["tenant"].FirstOrDefault();
        return Task.FromResult(tenantIdentifier);
    })...

```

--------------------------------

### Build from source with git clone and dotnet build

Source: https://www.finbuckle.com/MultiTenant/Docs

Clone the Finbuckle.MultiTenant repository, change into the new directory, and compile with dotnet build.

```bash
git clone https://github.com/Finbuckle/Finbuckle.MultiTenant.git
cd Finbuckle.MultiTenant
dotnet build

```

--------------------------------

### Bypass with custom condition using BypassWhen

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Use `BypassWhen()` to bypass tenant resolution based on a custom condition derived from `HttpContext`. This example bypasses for health check requests where the path starts with `/health`.

```csharp
// Bypass resolution for health check requests.
builder.Services.AddMultiTenant<TenantInfo>()
    .WithRouteStrategy()
    .WithConfigurationStore()
    .BypassWhen(options =>
    {
        options.Predicate = ctx => ctx.Request.Path.StartsWithSegments("/health");
    });
```

--------------------------------

### Configure WithEchoStore

Source: https://www.finbuckle.com/multitenant/docs/Stores

Configure the Echo Store, a read-only store that returns a new tenant instance based on the identifier. AddAsync, UpdateAsync, RemoveAsync, and GetAllAsync throw NotImplementedException.

```csharp
services.AddMultiTenant<TenantInfo>()
    .WithEchoStore();
```

--------------------------------

### Configure MyOptions with services.Configure

Source: https://www.finbuckle.com/multitenant/docs/Options

Show typical use of services.Configure with a delegate to set option values in a web application builder.

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<MyOptions>(options => options.Option1 = 1);
        
 // ...rest of app code

```

--------------------------------

### Exclude controller/action with ExcludeFromMultiTenantResolutionAttribute

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Use the `ExcludeFromMultiTenantResolutionAttribute` attribute on controllers or action methods to exclude them from tenant resolution. This example excludes an entire controller and a specific action. Bypassing runs before tenant resolution.

```csharp
// Exclude an entire controller.
[ExcludeFromMultiTenantResolution]
public class DashboardController : Controller
{
    // Or exclude just a specific action.
    [ExcludeFromMultiTenantResolution]
    public ActionResult Index()
    {
        return View();
    }
}
```

--------------------------------

### Configure options per tenant

Source: https://www.finbuckle.com/multitenant/docs/Options

Shows the PerTenant variants of Configure, PostConfigure, and ConfigureAll methods.

```csharp
using Finbuckle.MultiTenant.Extensions;

// configure options per tenant
builder.Services.ConfigurePerTenant<MyOptions, AppTenantInfo>((options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

// or configure named options per tenant
builder.Services.ConfigurePerTenant<MyOptions, AppTenantInfo>("scheme2", (options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

// ConfigureAll options variant
builder.Services.ConfigureAllPerTenant<MyOptions, AppTenantInfo>((options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

// can also configure post options, named post options, and all post options variants
builder.Services.PostConfigurePerTenant<MyOptions, AppTenantInfo>((options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

builder.Services.PostConfigurePerTenant<MyOptions, AppTenantInfo>("scheme2", (options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

builder.Services.PostConfigureAllPerTenant<MyOptions, AppTenantInfo>((options, tenantInfo) =>
    {
        options.Option1 = tenantInfo.Option1Value;
        options.Option2 = tenantInfo.Option2Value;
    });

```

--------------------------------

### Add Finbuckle.MultiTenant.EntityFrameworkCore package

Source: https://www.finbuckle.com/multitenant/docs/EFCore

Adds the Finbuckle.MultiTenant.EntityFrameworkCore package to the project, required for the multi-tenant functionality described in this section.

```bash
dotnet add package Finbuckle.MultiTenant.EntityFrameworkCore

```

--------------------------------

### Exclude endpoints with ExcludeFromMultiTenantResolution

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Use the `ExcludeFromMultiTenantResolution` extension method on `IEndpointConventionBuilder` to exclude specific endpoints from tenant resolution. This example excludes OpenAPI, a specific endpoint, a group, and static assets. Bypassing runs before tenant resolution.

```csharp
var app = builder.Build();

// Exclude OpenApi endpoints.
app.MapOpenApi()
    .ExcludeFromMultiTenantResolution();

// Exclude a specific endpoint.
app.MapGet("/oops", () => "Oops! An error happened.")
    .ExcludeFromMultiTenantResolution();

// Exclude a group of endpoints.
app.MapGroup("api/v{version:apiVersion}/dashboard")
    .ExcludeFromMultiTenantResolution();

// Exclude static asset endpoints.
app.MapStaticAssets()
    .ExcludeFromMultiTenantResolution();

app.Run();
```

--------------------------------

### Run unit tests with dotnet test

Source: https://www.finbuckle.com/MultiTenant/Docs

Run the unit tests from the command line using dotnet test from the solution directory.

```bash
dotnet test

```

--------------------------------

### Configure WithHeaderStrategy with default or custom header key

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Configure the header strategy with the default header key `__tenant__` or a custom key. The first block uses the default, the second passes a custom header key. Both are called after `AddMultiTenant<TenantInfo>`.

```csharp
// check for header "__tenant__" value
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHeaderStrategy()...
```

```csharp
// or check for custom header value
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHeaderStrategy("MyHeaderKey")...
```

--------------------------------

### Configure a custom strategy with WithStrategy<TStrategy>

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Shows two ways to configure a custom IMultiTenantStrategy after AddMultiTenant<TTenantInfo>. The first uses dependency injection with parameters, the second uses a factory method. The library decorates the strategy with logging and exception handling.

```csharp
// configure a strategy with a given type
builder.Services.AddMultiTenant<TenantInfo>()
    .WithStrategy<MyStrategy>(myParam1, myParam2)...

// or configure a strategy with a factory method
builder.Services.AddMultiTenant<TenantInfo>()
    .WithStrategy(sp => new MyStrategy())...

```

--------------------------------

### Minimal appsettings.json configuration store entry

Source: https://www.finbuckle.com/MultiTenant

This JSON defines a tenant with an ID, identifier, and name. The identifier must match the one from the host strategy for the tenant to be resolved.

```json
{
  "Finbuckle:MultiTenant:Stores:ConfigurationStore": {
    "Tenants": [
      {
        "Id": "93f330717e5d4f039cd05da312d559cc",
        "Identifier": "initech",
        "Name": "Initech"
      }
    ]
  }
}
```

--------------------------------

### Access options via DI and service provider

Source: https://www.finbuckle.com/multitenant/docs/Options

Demonstrates injecting IOptionsMonitor in a controller constructor and accessing options via a service provider.

```csharp
public class MyController : Controller
{
    private readonly MyOptions _myOptions;
    
    public MyController(IOptionsMonitor<MyOptions> optionsAccessor)
    {
        // same options regardless of the current tenant
        _myOptions = optionsAccessor.Value;
    }
}

```

```csharp
var options = httpContext.RequestServices.GetRequiredService<IOptionsSnapshot<MyOptions>>().Value;

```

--------------------------------

### Create tenant DbContext with MultiTenantDbContext.Create factory

Source: https://www.finbuckle.com/multitenant/docs/EFCore

Use the MultiTenantDbContext.Create factory to instantiate a tenant-specific DbContext without dependency injection, e.g., when looping through tenants. The factory supplies an IMultiTenantContextAccessor to the constructor; add DbContextOptions<T> or other dependencies via optional arguments. Dispose the context when done, preferably with a using block or variable.

```csharp
// create or otherwise obtain a tenant info instance
var tenantInfo = new MyTenantInfo { Id = "id", Identifier = "identifier" };

// create a database context instance for the tenant
var tenantDbContext = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenantInfo);

// create a database context instance for the tenant with an instance of DbContextOptions<AppMultiTenantDbContext>
var tenantDbContextWithOptions = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenantInfo, 
dbOptions);

// create a database context instance for the tenant with an instance of other dependencies
// the final parameter is params object[] so any number of dependency arguments can be used
var tenantDbContextWithOptions = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenantInfo, 
dep1, dep2, dep3);

// create a database context instance for the tenant with an instance pulled from a given service provider
var tenantDbContextWithOptions = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenantInfo, 
serviceProvider);

// create a database context instance for the tenant with an instance pulled from a given service provider
// and provided explicitly via params object[]
var tenantDbContextWithOptions = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenantInfo, 
serviceProvider, dep1, dep2, dep3);

// loop through a bunch of tenant instances
foreach (var tenant in tenants)
{
    using var tenantDbContext = MultiTenantDbContext.Create<AppMultiTenantDbContext, AppTenantInfo>(tenant);
    // do something with the database context
}
```

--------------------------------

### Configure per-tenant options with dependencies using OptionsBuilder

Source: https://www.finbuckle.com/multitenant/docs/Options

Use the OptionsBuilder API to configure per-tenant options with dependencies. The ConfigurePerTenant method takes a callback that receives the options, the dependency, and the tenant info. Note that MultiTenant supports up to four dependencies, unlike the standard OptionsBuilder which supports five.

```csharp
// use OptionsBuilder API to configure per-tenant options with dependencies
builder.Services.AddOptions<MyOptions>("optionalName")
    .ConfigurePerTenant<ExampleService, AppTenantInfo>(
        (options, es, tenantInfo) =>
            options.Option1 = DoSomethingWith(es, tenantInfo));

```

--------------------------------

### Configure Session Strategy with WithSessionStrategy

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Configure the session strategy with the default session key '__tenant__' or a custom key. The strategy is configured as a singleton and requires the app to configure session state and set the session variable. It is typically used before a more expensive strategy to cache the tenant resolution.

```csharp
// check for default "__tenant__" as the session key
builder.Services.AddMultiTenant<TenantInfo>()
    .WithSessionStrategy()...

// or check for a custom session key
builder.Services.AddMultiTenant<TenantInfo>()
    .WithSessionStrategy("my-tenant-session-key")...

```

--------------------------------

### Configure HttpRemoteStore with WithHttpRemoteStore

Source: https://www.finbuckle.com/multitenant/docs/Stores

Configure the HTTP remote store with WithHttpRemoteStore. The URI template must contain {__tenant__} or the identifier is appended. The store is read-only and throws NotImplementedException for write operations. A lambda can configure the HttpClient, including adding Polly resilience policies.

```csharp
// append the identifier to the provided url
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHttpRemoteStore("https://remoteserver.com/")...

```

```csharp
// or template the identifier into a custom location
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHttpRemoteStore("https://remoteserver.com/{__tenant__}/getinfo")...

```

```csharp
// or modify the underlying `HttpClient` with a custom message handler and settings
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHttpRemoteStore("https://remoteserver.com/", httpClientBuilder =>
    {
        httpClientBuilder.AddHttpMessageHandler<MyCustomHeaderHandler>();
        
        httpClientBuilder.ConfigureHttpClient( client =>
        {
            client.Timeout = TimeSpan.FromSeconds(10);
        });
    });

```

```csharp
// or add Polly support
// via https://www.hanselman.com/blog/AddingResilienceAndTransientFaultHandlingToYourNETCoreHttpClientWithPolly.aspx
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHttpRemoteStore("https://remoteserver.com/", httpClientBuilder =>
    {
        httpClientBuilder.AddTransientHttpErrorPolicy(policy => policyBuilder.RetryAsync(2));
    });

```

--------------------------------

### Configuration store JSON format with Defaults and Tenants

Source: https://www.finbuckle.com/multitenant/docs/Stores

JSON configuration format for the configuration store. The section name is 'Finbuckle:MultiTenant:Stores:ConfigurationStore'. Fields in the 'Defaults' section are automatically copied into each tenant unless the tenant specifies its own value. For a custom implementation of TenantInfo, its properties are mapped from the JSON automatically.

```json
{
  "Finbuckle:MultiTenant:Stores:ConfigurationStore": {
    "Defaults": {
      "ConnectionString": "default_connection_string"
    },
    "Tenants": [
      {
        "Id": "unique-id-0ff4daf",
        "Identifier": "tenant-1",
        "Name": "Tenant 1 Company Name",
        "ACustomProperty": "VIP Customer"
      },
      {
        "Id": "unique-id-ao41n44",
        "Identifier": "tenant-2",
        "Name": "Name of Tenant 2",
        "ConnectionString": "tenant_specific_connection_string"
      }
    ]
  }
}
```

--------------------------------

### Register custom store with WithStore<TStore> or factory method

Source: https://www.finbuckle.com/multitenant/docs/Stores

Shows two ways to register a custom IMultiTenantStore implementation: the generic WithStore<TStore> method with constructor parameters, and the non-generic WithStore overload accepting a factory method. Both are called after AddMultiTenant<TenantInfo> in ConfigureServices. The library wraps the store with logging and exception handling, so custom stores should avoid adding their own logging or validation.

```csharp
// register a custom store with the templated method
builder.Services.AddMultiTenant<TenantInfo>()
    .WithStore<MyStore>(ServiceLifetime.Singleton, myParam1, myParam2)...

// or register a custom store with the non-generic method, which accepts a factory method
builder.Services.AddMultiTenant<TenantInfo>()
    .WithStore(ServiceLifetime.Singleton, sp => new MyStore())...

```

--------------------------------

### Register WithConfigurationStore with default or custom path

Source: https://www.finbuckle.com/multitenant/docs/Stores

Registers the configuration store with the default root configuration and section name, or with a custom configuration path key. The store is case-insensitive when retrieving tenant information by tenant identifier and is read-only; calls to AddAsync, UpdateAsync, and RemoveAsync will throw a NotImplementedException. If the app is configured to reload its configuration when the source changes, the store will reflect the change.

```csharp
builder.Services.AddMultiTenant<TenantInfo>()
    .WithConfigurationStore()...
```

```csharp
builder.Services.AddMultiTenant<TenantInfo>()
    .WithConfigurationStore("customConfigurationPathKey")...
```

--------------------------------

### Configure Route Strategy with WithRouteStrategy

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Configure the route strategy with default or custom route parameter names. The first block shows default and custom parameter usage, plus the optional UseRouting placement. The second block enables ambient route value promotion for link generation.

```csharp
// use the default route parameter name "__tenant__"
builder.Services.AddMultiTenant<TenantInfo>()
  .WithRouteStrategy()...
    
// or set a different route parameter name of "MyTenantRouteParam" and do not add the tenant as an ambient route value
builder.Services.AddMultiTenant<TenantInfo>()
  .WithRouteStrategy("MyTenantRouteParam", false)...

// UseRouting is optional in ASP.NET Core, but if needed place before UseMultiTenant when the route strategy is used
app.UseRouting();
app.UseMultiTenant();

```

```csharp
builder.Services.AddMultiTenant<TenantInfo>()
    .WithRouteStrategy("tenant", useTenantAmbientRouteValue: true)
    .WithConfigurationStore();

```

--------------------------------

### Configure WithHostStrategy with default and custom patterns

Source: https://www.finbuckle.com/multitenant/docs/Strategies

Configure the host strategy in ASP.NET Core. The first call uses the default pattern (first host segment). The second uses a custom pattern to select the second-level domain segment. Both are chained after AddMultiTenant<TenantInfo>.

```csharp
// check the first domain segment (e.g. subdomain)
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()...

// check the second level domain segment (see 2nd example above)
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy("*.__tenant__.?")...

```

--------------------------------

### Configure EFCoreStore with WithEFCoreStore

Source: https://www.finbuckle.com/multitenant/docs/Stores

Configure the EFCore store by calling WithEFCoreStore after AddMultiTenant. The database context must derive from EFCoreStoreDbContext and is not itself multi-tenant. Case sensitivity is determined by the underlying EF Core database provider.

```csharp
// configure dbcontext `MultiTenantStoreDbContext`, which derives from `EFCoreStoreDbContext`
builder.Services.AddMultiTenant<TenantInfo>()
    .WithEFCoreStore<MultiTenantStoreDbContext,TenantInfo>()...

```

--------------------------------

### Enable passkey support with Identity schema version 3

Source: https://www.finbuckle.com/multitenant/docs/Identity

Configure IdentityOptions to set Stores.SchemaVersion to 3.0, enabling passkey support with multi-tenant configuration. No additional DbContext configuration is needed; MultiTenantIdentityDbContext detects the schema version.

```csharp
services.AddOptions();
services.Configure<IdentityOptions>(o =>
{
    // Use Identity schema version 3 to enable passkeys
    o.Stores.SchemaVersion = new Version(3, 0);
});

```

--------------------------------

### ShortCircuitWhenTenantNotResolved() with optional redirect

Source: https://www.finbuckle.com/multitenant/docs/AspNetCore

Configure the MultiTenantMiddleware to short circuit the request pipeline when no tenant is resolved. The first call halts request handling; the second redirects to a relative URI. Use this after AddMultiTenant<TTenantInfo> and note that endpoints not requiring a tenant must be excluded, otherwise they will never be reached.

```csharp
// Simply short circuit the request, ending request handling.
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore()
    .ShortCircuitWhenTenantNotResolved();

// Short circuit and redirect to a specific Uri.
builder.Services.AddMultiTenant<TenantInfo>()
    .WithHostStrategy()
    .WithConfigurationStore()
    .ShortCircuitWhenTenantNotResolved(new Uri("/tenant/notfound", UriKind.Relative));

```

--------------------------------

### Adding Data with MultiTenantDbContext and MultiTenantException

Source: https://www.finbuckle.com/multitenant/docs/EFCore

Shows how to add an entity to a tenant's context and then attempt to add the same entity to a different tenant, which throws a MultiTenantException on SaveChangesAsync. The entity's TenantId is set explicitly, and the context is created via MultiTenantDbContext.Create with a TenantInfo.

```csharp
var myBlog = new Blog { TenantId = "1", Title = "My Blog" };

// Add the blog to a db context for a tenant.
var myTenantInfo = new TenantInfo { Id = "1", Identifier = "tenant-1" };
var myDbContext = MultiTenantDbContext.Create<BloggingDbContext, TenantInfo>(myTenantInfo);
myDbContext.Blogs.Add(myBlog);
myDbContext.SaveChanges();

// Try to add the same blog to a different tenant.
var yourTenantInfo = new TenantInfo { Id = "2", Identifier = "tenant-2" };
var yourDbContext = MultiTenantDbContext.Create<BloggingDbContext, TenantInfo>(yourTenantInfo);
yourDbContext.Blogs.Add(myBlog);
await yourDbContext.SaveChangesAsync(); // Throws MultiTenantException.
```
Tokens:
Raw