Cheap Windows Hosting Review

Creating a Multi-Tenant Architecture with EF Core in ASP.NET Core

Posted on by Pablo Francesco

A single application instance serves several clients (tenants), each of whom is logically isolated from the others, according to the potent multi-tenancy architectural pattern. SaaS (Software-as-a-Service) solutions frequently use this strategy for cost optimization, scalability, and efficiency.

This article will discuss how to use Entity Framework Core (EF Core) to design and build multi-tenant architecture in ASP.NET Core, with an emphasis on tenant identification, database separation, and data management techniques.

1. Comprehending Multi-Tenancy Models
It’s crucial to comprehend the typical forms of multi-tenancy before beginning implementation:

a) Shared Schema, Single Database
The database and tables are shared by all tenants. Each table has a TenantId column that identifies tenant data.

Advantages: Economical and easy to maintain.

Cons: Inadequate data isolation and increased danger of data leaks between tenants.

b) One Database, Different Schemas

Every tenancy has a unique schema, such as TenantA.Users and TenantB.Users.

Advantages: Improved seclusion.

Cons: More tenants make it more difficult to scale.

c) Different databases for each tenant

Every tenant has a database of their own.

Strong isolation and adaptability are advantages.

Cons: Higher costs and more complicated management.

2. Configuring Middleware for Tenant Identification
Each request needs to specify whose tenant it pertains to. Typical methods of identification consist of:

Subdomain-based (tenant1.app.com, for example)

Path-based (such as app.com/tenant1)

header-based (using a unique header such as X-Tenant-ID)

Tenant Identification Middleware, for instance

public class TenantMiddleware
{
private readonly RequestDelegate _next;

public TenantMiddleware(RequestDelegate next)
{
_next = next;
}

public async Task Invoke(HttpContext context, ITenantService tenantService)
{
var tenantId = context.Request.Headers["X-Tenant-ID"].FirstOrDefault();

if (string.IsNullOrEmpty(tenantId))
{
context.Response.StatusCode = 400;
await context.Response.WriteAsync("Tenant ID missing");
return;
}

tenantService.SetTenant(tenantId);
await _next(context);
}
}

And register it in Startup.cs or Program.cs:
app.UseMiddleware<TenantMiddleware>();

3. Creating the Tenant Service
This service manages the active tenant for the current request.
public interface ITenantService
{
string GetTenant();
void SetTenant(string tenantId);
}

public class TenantService : ITenantService
{
private string _tenantId;
public string GetTenant() => _tenantId;
public void SetTenant(string tenantId) => _tenantId = tenantId;
}

Register it as a scoped service:
builder.Services.AddScoped<ITenantService, TenantService>();

4. Configuring EF Core for Multi-Tenancy
If using separate databases, dynamically build the connection string per tenant:
public class TenantDbContext : DbContext
{
private readonly ITenantService _tenantService;
private readonly IConfiguration _configuration;

public TenantDbContext(DbContextOptions<TenantDbContext> options, ITenantService tenantService, IConfiguration configuration)
: base(options)
{
_tenantService = tenantService;
_configuration = configuration;
}

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var tenantId = _tenantService.GetTenant();
var connectionString = _configuration.GetConnectionString("DefaultConnection").Replace("{tenantId}", tenantId);
optionsBuilder.UseSqlServer(connectionString);
}

public DbSet<Customer> Customers { get; set; }
}
In your appsettings.json:

"ConnectionStrings": {
"DefaultConnection": "Server=.;Database=Tenant_{tenantId};Trusted_Connection=True;"
}

5. Applying a Tenant Filter (Shared Schema Approach)
If using a shared schema, apply a global query filter:
public class ApplicationDbContext : DbContext
{
private readonly ITenantService _tenantService;

public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options, ITenantService tenantService)
: base(options)
{
_tenantService = tenantService;
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Customer>().HasQueryFilter(c => c.TenantId == _tenantService.GetTenant());
}

public DbSet<Customer> Customers { get; set; }
}

This ensures that all queries automatically filter by the current tenant’s data.

6. Example Controller

[ApiController]
[Route("api/[controller]")]
public class CustomersController : ControllerBase
{
private readonly TenantDbContext _context;

public CustomersController(TenantDbContext context)
{
_context = context;
}

[HttpGet]
public async Task<IActionResult> GetCustomers()
{
var customers = await _context.Customers.ToListAsync();
return Ok(customers);
}
}

7. Practical Example in Action
Request

GET /api/customers
Header: X-Tenant-ID = TenantA
Database Connection Used

Server=.;Database=Tenant_TenantA;Trusted_Connection=True;

Result
Returns only data from TenantA’s database or filtered by TenantA’s TenantId.

8. Best Practices

  • Use caching for tenant configuration lookups.
  • Secure tenant isolation — never allow direct TenantId exposure in client-side apps.
  • Automate database provisioning using background jobs.
  • Use migrations per tenant if using isolated databases.
  • Regularly audit access and data isolation between tenants.

Conclusion

Scalability, cost effectiveness, and simpler maintenance for SaaS companies are made possible by implementing multi-tenancy in ASP.NET Core using EF Core. You may customize this architecture to guarantee that each tenant’s data is safe, reliable, and efficient based on your business needs, whether they involve lightweight shared databases or completely isolated ones.

In addition to lowering infrastructure costs, a well-designed multi-tenant system offers a solid platform for growing your application to hundreds of tenants with little architectural modification.

Best ASP.NET Core 10.0 Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core 10.0 hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core 10.0 version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFE.eu guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.

hostforlifebanner