Multiteancy Implementation On Single Database With Same Schema

Most of the people are implementing Multi-Tenancy using multiple databases, hence it's a good practice to distinguish tenant data on different databases. But in some cases, we have to implement multi-tenancy in the same database. So, I am going to write my logic on how I have implemented multi-tenancy on the same database. It will definitely help you.

Most of the people are implementing Multi-Tenancy using multiple databases, hence it's a good practice to distinguish tenant data on different databases. But in some cases, we have to implement multi-tenancy in the same database.

 

So, I am going to write my logic on how I have implemented multi-tenancy on the same database. It will definitely help you. For Multi-Tenancy implementation, I have used the EF Core 2.1 version.

 

Before implementation, please install NuGet package EF core 2.1.

 

PM > Install-Package Microsoft.EntityFrameworkCore -Version 2.1.0  

 

Generally, we will load our configuration like this in the OnModelcreating method.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.ApplyConfiguration(new TenantEntityTypeConfiguration());
}

But when you have 'n' number of tables and configurations, you have to apply configurations 'n' number of times. Rather than specifying configurations manually, we can load all the configurations by using this logic.

Assembly assembly = Assembly.GetExecutingAssembly();

Initialize the assembly, then find out all the configuration on your solution.

var configurations = assembly.DefinedTypes.Where(t => t.ImplementedInterfaces.Any(i => i.IsGenericType && i.Name.Equals(typeof(IEntityTypeConfiguration < > ).Name, StringComparison.InvariantCultureIgnoreCase)) && t.IsClass && !t.IsAbstract && !t.IsNested).ToList();

By using "IEntityTypeConfiguration" type we will list out all the configurations using assemblies, Once list out all the configurations, we have instantiate by using below code.

foreach(var configuration in configurations) {
    var entityType = configuration.GetInterfaces().Single().GenericTypeArguments.Single();
    var applyConfigMethods = typeof(ModelBuilder).GetMethods(BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name.Equals("ApplyConfiguration") && m.IsGenericMethod);
    var applyConfigMethod = applyConfigMethods.Single(m => m.GetParameters().Any(p => p.ParameterType.Name.Equals(typeof(IEntityTypeConfiguration < > ).Name)));
    var method = applyConfigMethod.MakeGenericMethod(entityType);
    method.Invoke(modelBuilder, new object[] {
        Activator.CreateInstance(configuration)
    });
}

This will help to load all your configuration generically.

 

Here are multiple ways to apply the filtering to the logic of your entities.

 

This is the simplest way, to apply your filtering logic to an entity, but you have to apply this logic to each entity. level.

 

Using this filtering logic you don't need above logic, load all your configurations manually and apply filtering logic.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.ApplyConfiguration(new TenantEntityTypeConfiguration());
   modelBuilder.Entity<Tenant>().HasQueryFilter(t => t.Id == 1);
}

Other way it's a generic way to apply filerting logic for this you have to load all your configuration either manually or generically.

protected override void OnModelCreating(ModelBuilder modelBuilder) {
    //load all your configuration like use above generic logic or manually like this
    modelBuilder.ApplyConfiguration(new TenantEntity1TypeConfiguration());
    modelBuilder.ApplyConfiguration(new TenantEntity2TypeConfiguration());
    modelBuilder.ApplyConfiguration(new TenantEntity3TypeConfiguration());
    modelBuilder.ApplyConfiguration(new TenantEntity4TypeConfiguration());
    //here you will apply the filtering generically
    foreach(var type in GetEntityTypes()) {
        var method = SetGlobalQueryMethod.MakeGenericMethod(type);
        method.Invoke(this, new object[] {
            modelBuilder
        });
    }
}
private static IList < Type > GetEntityTypes() {
    if (_entityTypeCache != null) {
        return _entityTypeCache.ToList();
    }
    _entityTypeCache = (from a in GetReferencingAssemblies() from t in a.DefinedTypes where t.BaseType == typeof(Entity) select t.AsType()).ToList();
    return _entityTypeCache;
}
private static IEnumerable < Assembly > GetReferencingAssemblies() {
    var assemblies = new List < Assembly > ();
    foreach(var assemblyName in Assembly.GetExecutingAssembly().GetReferencedAssemblies()) {
        try {
            Assembly assembly = Assembly.Load(assemblyName.Name);
            assemblies.Add(assembly);
        } catch (FileNotFoundException) {}
    }
    return assemblies;
}
static readonly MethodInfo SetGlobalQueryMethod = typeof(CustomerSuccessContext).GetMethods(BindingFlags.Public | BindingFlags.Instance).Single(t => t.IsGenericMethod && t.Name == "SetGlobalQuery");
public void SetGlobalQuery < T > (ModelBuilder builder) where T: class {
    builder.Entity < T > ().HasQueryFilter(e => EF.Property < int > (e, "table columnname") == "your tenantid");
    ///eg:- builder.Entity<T>().HasQueryFilter(e => EF.Property<int>(e, "TenantId") == _tenantId);
}