De manière dynamique l'évolution de schéma dans le Cadre de l'Entité de Base

Il ya un couple de façons de le faire:

• Construire le modèle de l'extérieur et de le transmettre via DbContextOptionsBuilder.UseModel()
• Remplacer le IModelCacheKeyFactory service de avec un qui prend le schéma en compte

OriginalL'auteur bricelam

Désolé tout le monde, je devrais ai posté une solution avant, mais pour une raison que je ne l'ai pas, si elle est ici.

MAIS

Garder à l'esprit que tout ce qui pourrait être mal avec la solution car il ni a pas été examiné par personne, ni de la production a été, probablement, je vais obtenir des commentaires ici.

Dans le projet, j'ai utilisé ASP .NET de Base 1

---

Sur ma db structure. J'ai 2 contextes. La première contient des informations sur les utilisateurs (y compris la db régime, ils devraient adresse), le second contient des données spécifiques à l'utilisateur.

Dans Startup.cs - je ajouter les deux contextes

public void ConfigureServices(IServiceCollection 
services.AddEntityFrameworkNpgsql()
.AddDbContext<SharedDbContext>(options =>
options.UseNpgsql(Configuration["MasterConnection"]))
.AddDbContext<DomainDbContext>((serviceProvider, options) => 
options.UseNpgsql(Configuration["MasterConnection"])
.UseInternalServiceProvider(serviceProvider));
...
services.Replace(ServiceDescriptor.Singleton<IModelCacheKeyFactory, MultiTenantModelCacheKeyFactory>());
services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();

Avis UseInternalServiceProvider partie, il a été suggéré par Nero Sule avec l'explication suivante

À la fin de la CEF 1er cycle d'évaluation, l'équipe EF a décidé de retirer EF services de la valeur par défaut du service de collecte (AddEntityFramework().AddDbContext()), ce qui signifie que les services sont résolus à l'aide de EF est propre fournisseur de service plutôt que le fournisseur de service d'application.

De force EF à l'utilisation de votre application, fournisseur de services au lieu de cela, vous devez d'abord ajouter EF de services en collaboration avec le fournisseur de données à votre service à la collection, puis configurer DBContext d'utiliser un prestataire de services interne

Maintenant nous avons besoin de MultiTenantModelCacheKeyFactory

public class MultiTenantModelCacheKeyFactory : ModelCacheKeyFactory {
private string _schemaName;
public override object Create(DbContext context) {
var dataContext = context as DomainDbContext;
if(dataContext != null) {
_schemaName = dataContext.SchemaName;
}
return new MultiTenantModelCacheKey(_schemaName, context);
}
}

où DomainDbContext est le contexte avec des données spécifiques à l'utilisateur

public class MultiTenantModelCacheKey : ModelCacheKey {
private readonly string _schemaName;
public MultiTenantModelCacheKey(string schemaName, DbContext context) : base(context) {
_schemaName = schemaName;
}
public override int GetHashCode() {
return _schemaName.GetHashCode();
}
}

Nous devons aussi changer un peu le contexte lui-même pour en faire un schéma courant:

public class DomainDbContext : IdentityDbContext<ApplicationUser> {
public readonly string SchemaName;
public DbSet<Foo> Foos{ get; set; }
public DomainDbContext(ICompanyProvider companyProvider, DbContextOptions<DomainDbContext> options)
: base(options) {
SchemaName = companyProvider.GetSchemaName();
}
protected override void OnModelCreating(ModelBuilder modelBuilder) {
modelBuilder.HasDefaultSchema(SchemaName);
base.OnModelCreating(modelBuilder);
}
}

et le contexte partagé est strictement liée à shared schéma:

public class SharedDbContext : IdentityDbContext<ApplicationUser> {
private const string SharedSchemaName = "shared";
public DbSet<Foo> Foos{ get; set; }
public SharedDbContext(DbContextOptions<SharedDbContext> options)
: base(options) {}
protected override void OnModelCreating(ModelBuilder modelBuilder) {
modelBuilder.HasDefaultSchema(SharedSchemaName);
base.OnModelCreating(modelBuilder);
}
}

ICompanyProvider est responsable de la gestion des utilisateurs nom de schéma. Et oui, je sais comment loin de l'idéal de code, il est.

public interface ICompanyProvider {
string GetSchemaName();
}
public class CompanyProvider : ICompanyProvider {
private readonly SharedDbContext _context;
private readonly IHttpContextAccessor _accesor;
private readonly UserManager<ApplicationUser> _userManager;
public CompanyProvider(SharedDbContext context, IHttpContextAccessor accesor, UserManager<ApplicationUser> userManager) {
_context = context;
_accesor = accesor;
_userManager = userManager;
}
public string GetSchemaName() {
Task<ApplicationUser> getUserTask = null;
Task.Run(() => {
getUserTask = _userManager.GetUserAsync(_accesor.HttpContext?.User);
}).Wait();
var user = getUserTask.Result;
if(user == null) {
return "shared";
}
return _context.Companies.Single(c => c.Id == user.CompanyId).SchemaName;
}
}

Et si je n'ai pas oublié quelque chose, c'est tout. Maintenant, dans chaque requête par un utilisateur authentifié, le contexte approprié sera utilisé.

J'espère que cela aide.

OriginalL'auteur user3272018

peut-être que je suis un peu en retard pour cette réponse

mon problème était de la manipulation de schéma différent avec la même structure permet de dire multi-locataire.

Quand j'ai essayé de créer différentes instances d'un même contexte pour les différents schémas, Entité cadres 6 vient de jouer, attraper la première fois le dbContext a été créé puis pour les cas suivants ils ont été crée avec différents schémas de nom mais onModelCreating n'ont jamais été appelés ce qui signifie que chaque instance a été pointant vers le même auparavant exercé Pré-Vues", en pointant sur le premier schéma.

Puis j'ai réalisé que la création de nouvelles classes héritant de myDBContext un pour chaque schéma permettra de résoudre mon problème en surmontant entity Framework attraper problème de la création d'un nouveau contexte pour chaque schéma, mais ensuite vient le problème que nous nous retrouverons avec codé en dur schémas, à l'origine d'un autre problème en termes de code de l'évolutivité lorsque nous avons besoin d'ajouter un autre schéma, d'avoir à ajouter plus de classes et de rassembler et de publier une nouvelle version de l'application.

J'ai donc décidé d'aller un peu plus loin, à la création, à la compilation et à l'ajout de classes à la solution actuelle dans l'exécution.

Voici le code

public static MyBaseContext CreateContext(string schema)
{
MyBaseContext instance = null;
try
{
string code = $@"
namespace MyNamespace
{{
using System.Collections.Generic;
using System.Data.Entity;
public partial class {schema}Context : MyBaseContext
{{
public {schema}Context(string SCHEMA) : base(SCHEMA)
{{
}}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{{
base.OnModelCreating(modelBuilder);
}}
}}
}}
";
CompilerParameters dynamicParams = new CompilerParameters();
Assembly currentAssembly = Assembly.GetExecutingAssembly();
dynamicParams.ReferencedAssemblies.Add(currentAssembly.Location);   //Reference the current assembly from within dynamic one
//Dependent Assemblies of the above will also be needed
dynamicParams.ReferencedAssemblies.AddRange(
(from holdAssembly in currentAssembly.GetReferencedAssemblies()
select Assembly.ReflectionOnlyLoad(holdAssembly.FullName).Location).ToArray());
//Everything below here is unchanged from the previous
CodeDomProvider dynamicLoad = CodeDomProvider.CreateProvider("C#");
CompilerResults dynamicResults = dynamicLoad.CompileAssemblyFromSource(dynamicParams, code);
if (!dynamicResults.Errors.HasErrors)
{
Type myDynamicType = dynamicResults.CompiledAssembly.GetType($"MyNamespace.{schema}Context");
Object[] args = { schema };
instance = (MyBaseContext)Activator.CreateInstance(myDynamicType, args);
}
else
{
Console.WriteLine("Failed to load dynamic assembly" + dynamicResults.Errors[0].ErrorText);
}
}
catch (Exception ex)
{
string message = ex.Message;
}
return instance;
}

J'espère que cela aide quelqu'un pour gagner du temps.

OriginalL'auteur Randy