Comment puis-je injecter une chaîne de connexion dans une instance de IDbContextFactory & lt; T & gt ;?

Voici la démarche que j'ai finalement utilisé, à l'aide de la coutume IDatabaseInitializer<T> code de cette réponsequi m'a aidé beaucoup.

Nous avons d'abord ajouter un autre constructeur de la DataStore classe (DbContext) qui ne nécessite pas le paramètre de chaîne de connexion:

public class DataStore : DbContext, IDataStore
{
    public int UserID { get; private set; }

    //This is the constructor that will be called by the factory class 
    //if it is initialised without a connection string parameter
    public DataStore(int userId)
    {
        UserID = userId;
    }

    public DataStore(int userId, string connectionString) : base(connectionString)
    {
        UserID = userId;
    }

    public virtual IDbSet<User> Users { get; set; }

    //Rest of code here
}

Puis nous faisons la même chose pour l'usine de classe:

public class DataStoreFactory : Disposable, IDataStoreFactory
{
    private DataStore _database;
    private int _userId;
    private string _connectionString;

    //This is the constructor that will be called by the 
    //MigrationDataStoreFactory class
    public DataStoreFactory(int userId)
    {
        _userId = userId;
    }

    public DataStoreFactory(int userId, string connectionString)
    {
        _userId = userId;
        _connectionString = connectionString;
    }

    public IDataStore Get()
    {
        //If we have a connection string, construct our context with it,
        //if not, use the new constructor
        if(_connectionString != null)
            _database = new DataStore(_userId, _dateTimeServices, _connectionString);
        else
            _database = new DataStore(_userId, _dateTimeServices);

        return _database;
    }

    protected override void DisposeCore()
    {
        if (_database != null) _database.Dispose();
    }
}

C'est la coutume de l'initialiseur de code:

public class MigrateDatabaseToLatestVersionWithConnectionString<TContext, TMigrationsConfiguration> : IDatabaseInitializer<TContext>
    where TContext : DbContext
    where TMigrationsConfiguration : DbMigrationsConfiguration<TContext>, new()
{
    private readonly DbMigrationsConfiguration _config;

    public MigrateDatabaseToLatestVersionWithConnectionString()
    {
        _config = new TMigrationsConfiguration();
    }

    public MigrateDatabaseToLatestVersionWithConnectionString(string connectionString)
    {
        //Set the TargetDatabase for migrations to use the supplied connection string
        _config = new TMigrationsConfiguration { 
            TargetDatabase = new DbConnectionInfo(connectionString, 
                                                  "System.Data.SqlClient")
        };
    }

    public void InitializeDatabase(TContext context)
    {
        //Update the migrator with the config containing the right connection string
        DbMigrator dbMigrator = new DbMigrator(_config);
        dbMigrator.Update();
    }
}

Notre contexte personnalisé de l'usine (qui n'est jamais appelée par le Code des Premières Migrations) peuvent maintenant porter sur l'utilisation de la DataStore constructeur qui n'est pas nécessitent une chaîne de connexion:

public class MigrationDataStoreFactory : IDbContextFactory<DataStore>
{
    public DataStore Create()
    {
        return new DataStore(0); 
    }
}

Aussi longtemps que nous avons mis l'initialiseur de base de données à notre coutume d'initialiseur et passer dans la chaîne de connexion (qui dans mon cas est fait dans Global.asax), les migrations vont utiliser la connexion correcte:

Database.SetInitializer<DataStore>(new MigrateDatabaseToLatestVersionWithConnectionString<DataStore, MyMigrationsConfiguration>(INJECTED_CONNECTION_STRING_HERE));

De l'espoir à tout ce qui fait sens—n'hésitez pas à demander des précisions dans les commentaires.