ASP.NET changement de Base EF chaîne de connexion lorsque l'utilisateur se connecte au

En fonction de votre question, je vais apporter une solution en supposant que certaines choses:

Tout d'abord, j'ai créé trois bases de données dans mon instance locale de SQL Server:

create database CompanyFoo
go
create database CompanyBar
go
create database CompanyZaz
go

Alors, je vais créer un tableau avec une ligne dans chaque base de données:

use CompanyFoo
go
drop table ConfigurationValue
go
create table ConfigurationValue
(
Id int not null identity(1, 1),
Name varchar(255) not null,
[Desc] varchar(max) not null
)
go
insert into ConfigurationValue values ('Company name', 'Foo Company')
go
use CompanyBar
go
drop table ConfigurationValue
go
create table ConfigurationValue
(
Id int not null identity(1, 1),
Name varchar(255) not null,
[Desc] varchar(max) not null
)
go
insert into ConfigurationValue values ('Company name', 'Bar Company')
go
use CompanyZaz
go
drop table ConfigurationValue
go
create table ConfigurationValue
(
Id int not null identity(1, 1),
Name varchar(255) not null,
[Desc] varchar(max) not null
)
go
insert into ConfigurationValue values ('Company name', 'Zaz Company')
go

Prochaine étape est de créer un utilisateur avec l'Authentification SQL et accorder l'accès à lire les bases de données, dans mon cas, mon nom d'utilisateur est johnd et le mot de passe est 123.

Une fois ces étapes terminées, nous allons créer une application MVC dans ASP.NET de Base, j'ai utilisé MultipleCompany comme nom de projet, j'ai deux contrôleurs: Accueil et de l'Administration, l'objectif est de montrer une connexion en premier et ensuite rediriger vers un autre point de vue pour afficher les données selon la base de données sélectionnée dans "login".

Pour accomplir votre exigence, vous aurez besoin d'utiliser la session sur ASP.NET application de Base vous pouvez modifier ce moyen de stockage et de lire les données plus tard, pour l'instant c'est pour le concept de test uniquement.

HomeController code:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using MultipleCompany.Models;
namespace MultipleCompany.Controllers
{
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
[HttpPost]
public IActionResult Index(LoginModel model)
{
HttpContext.Session.SetString("CompanyCode", model.CompanyCode);
HttpContext.Session.SetString("UserName", model.UserName);
HttpContext.Session.SetString("Password", model.Password);
return RedirectToAction("Index", "Administration");
}
public IActionResult Error()
{
return View();
}
}
}

AdministrationController code:

using System.Linq;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using MultipleCompany.Models;
using MultipleCompany.Services;
namespace MultipleCompany.Controllers
{
public class AdministrationController : Controller
{
protected IDbContextService DbContextService;
protected CompanyDbContext DbContext;
public AdministrationController(IDbContextService dbContextService)
{
DbContextService = dbContextService;
}
public override void OnActionExecuting(ActionExecutingContext context)
{
DbContext = DbContextService.CreateCompanyDbContext(HttpContext.Session.CreateLoginModelFromSession());
base.OnActionExecuting(context);
}
public IActionResult Index()
{
var model = DbContext.ConfigurationValue.ToList();
return View(model);
}
}
}

Code de la vue d'Accueil:

@{
ViewData["Title"] = "Home Page";
}
<form action="/home" method="post">
<fieldset>
<legend>Log in</legend>
<div>
<label for="CompanyCode">Company code</label>
<select name="CompanyCode">
<option value="CompanyFoo">Foo</option>
<option value="CompanyBar">Bar</option>
<option value="CompanyZaz">Zaz</option>
</select>
</div>
<div>
<label for="UserName">User name</label>
<input type="text" name="UserName" />
</div>
<div>
<label for="Password">Password</label>
<input type="password" name="Password" />
</div>
<button type="submit">Log in</button>
</fieldset>
</form>

Code de la vue Administration:

@{
ViewData["Title"] = "Home Page";
}
<h1>Welcome!</h1>
<table class="table">
<tr>
<th>Name</th>
<th>Desc</th>
</tr>
@foreach (var item in Model)
{
<tr>
<td>@item.Name</td>
<td>@item.Desc</td>
</tr>
}
</table>

LoginModel code:

using System;
using Microsoft.AspNetCore.Http;
namespace MultipleCompany.Models
{
public class LoginModel
{
public String CompanyCode { get; set; }
public String UserName { get; set; }
public String Password { get; set; }
}
public static class LoginModelExtensions
{
public static LoginModel CreateLoginModelFromSession(this ISession session)
{
var companyCode = session.GetString("CompanyCode");
var userName = session.GetString("UserName");
var password = session.GetString("Password");
return new LoginModel
{
CompanyCode = companyCode,
UserName = userName,
Password = password
};
}
}
}

CompanyDbContext code:

using System;
using Microsoft.EntityFrameworkCore;
namespace MultipleCompany.Models
{
public class CompanyDbContext : Microsoft.EntityFrameworkCore.DbContext
{
public CompanyDbContext(String connectionString)
{
ConnectionString = connectionString;
}
public String ConnectionString { get; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(ConnectionString);
base.OnConfiguring(optionsBuilder);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}
public DbSet<ConfigurationValue> ConfigurationValue { get; set; }
}
}

ConfigurationValue code:

using System;
namespace MultipleCompany.Models
{
public class ConfigurationValue
{
public Int32? Id { get; set; }
public String Name { get; set; }
public String Desc { get; set; }
}
}

AppSettings code:

using System;
namespace MultipleCompany.Models
{
public class AppSettings
{
public String CompanyConnectionString { get; set; }
}
}

IDbContextService code:

using MultipleCompany.Models;
namespace MultipleCompany.Services
{
public interface IDbContextService
{
CompanyDbContext CreateCompanyDbContext(LoginModel model);
}
}

DbContextService code:

using System;
using Microsoft.Extensions.Options;
using MultipleCompany.Models;
namespace MultipleCompany.Services
{
public class DbContextService : IDbContextService
{
public DbContextService(IOptions<AppSettings> appSettings)
{
ConnectionString = appSettings.Value.CompanyConnectionString;
}
public String ConnectionString { get; }
public CompanyDbContext CreateCompanyDbContext(LoginModel model)
{
var connectionString = ConnectionString.Replace("{database}", model.CompanyCode).Replace("{user id}", model.UserName).Replace("{password}", model.Password);
var dbContext = new CompanyDbContext(connectionString);
return dbContext;
}
}
}

Code de démarrage:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using MultipleCompany.Models;
using MultipleCompany.Services;
namespace MultipleCompany
{
public class Startup
{
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
}
public IConfigurationRoot Configuration { get; }
//This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//Add framework services.
services.AddMvc();
services.AddEntityFrameworkSqlServer().AddDbContext<CompanyDbContext>();
services.AddScoped<IDbContextService, DbContextService>();
services.AddDistributedMemoryCache();
services.AddSession();
services.AddOptions();
services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
services.AddSingleton<IConfiguration>(Configuration);
}
//This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseSession();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
}
}

J'ai ajouté cette packages pour mon projet:

"Microsoft.EntityFrameworkCore": "1.0.1",
"Microsoft.EntityFrameworkCore.SqlServer": "1.0.1",
"Microsoft.AspNetCore.Session":  "1.0.0"

Mon appsettings.fichier json:

{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
},
"AppSettings": {
"CompanyConnectionString": "server=(local);database={database};user id={user id};password={password}"
}
}

Veuillez vous mettre l'accent sur le concept de sujet pour se connecter à la base de données sélectionné dans la vue d'accueil, vous pouvez modifier une partie de ce code comme une amélioration, veuillez vous rappeler que je suis fournissant cette solution en faisant certaines hypothèses selon votre brève question, n'hésitez pas à demander au sujet de tout exposé aspect de cette solution pour améliorer ce morceau de code en fonction de vos besoins.

Fondamentalement, nous avons besoin de définir un service permettant de créer une instance de la base de données de contexte selon la base de données sélectionnée, c'est IDbContextService interface et DbContextService c'est l'implémentation de cette interface.

Comme vous pouvez le voir sur DbContextService code, on remplace les valeurs à l'intérieur de {} pour construire différents de la chaîne de connexion, dans ce cas, j'ai ajouté les noms de base de données dans la liste déroulante, mais dans le développement réel merci d'éviter de cette façon parce que, pour des raisons de sécurité, il est préférable de ne pas exposer les vrais noms de vos bases de données et d'autres configurations, vous pouvez avoir une parité table à partir du contrôleur de côté pour résoudre le code de l'entreprise selon la base de données sélectionnée.

Une amélioration pour cette solution, ce serait d'ajouter un peu de code pour sérialiser modèle de connexion sous forme de json dans la session au lieu de la stocker chaque valeur distincte.

S'il vous plaît laissez-moi savoir si cette réponse est utile.
PD: Laissez-moi savoir dans les commentaires si vous voulez le code complet à télécharger dans un lecteur

OriginalL'auteur H. Herzl

Vous avez trouvé votre réponse, mais peut-être que mon post peut être utile pour quelqu'un. J'ai eu un problème semblable à cette question. J'ai dû changer mon entity framework connectionstring pour connecter les différentes serveur de base de données après que l'utilisateur est connecté. Et pour tout d'abord la solution que j'ai supprimé cette fonction de ma classe de contexte,

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!optionsBuilder.IsConfigured)
{
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
optionsBuilder.UseSqlServer("your connectionstring...");
}

parce que je ne pouvais pas appelé à cette fonction à partir de l'extérieur. Et j'ai eu cette auto constructeur généré

 public ClientContext(DbContextOptions<ClientContext> options)
: base(options)
{
}

Après la suppression, j'ai ajouté ce code de ma classe de contexte.

public ClientContext CreateConnectionFromOut(string connectionString)
{
var optionsBuilder = new DbContextOptionsBuilder<Esdesk_ClientContext>();
optionsBuilder.UseSqlServer(connectionString);
var context = new ClientContext(optionsBuilder.Options);
return context;
}

Enfin, maintenant, je peux changer ma chaîne de connexion à partir où je veux. C'est juste comme ça,

   ClientContext cc = new ClientContext();
var db = cc.CreateConnectionFromOut("your connection string");

Espère que cela peut être bon pour quelqu'un.

OriginalL'auteur Emre SOLUĞAN

Vous pouvez essayer ce qui suit lors de la création de votre instance de contexte:

//in class DBHelper
public static YourEntities GetDbContext(string tenantName) 
{
var connectionStringTemplate =
@"metadata=res://*/yourModel.csdl|res://*/yourModel.ssdl|res://*/yourModel.msl;" +
@"provider=System.Data.SqlClient;" +
@"provider connection string=""data source=.;" +
@"initial catalog={0};" +
@"user id=sa;password=pwd;" +
@"MultipleActiveResultSets=True;App=EntityFramework"";";
var connectionString = string.Format(connection, tenantName);
var db = new YourEntities(connectionString);
return db;
}

Puis faire un constructeur dans votre classe de contexte qui accepte une chaîne de caractères en paramètre, et l'utiliser comme:

var db = DBHelper.GetDbContext(name of database to connect);

OriginalL'auteur Awais Mahmood