Ajouter un DbProviderFactory sans une Application.Config

JoshRivers ci-dessus posté une solution pour SQLite. Cela peut en effet être utilisé pour d'autres cartes comme le bien - j'ai été capable de le faire travailler pour MySQL à l'aide de son exemple. J'ai enroulé dans quelque chose d'un peu plus générique. Ce doit être exécuté une fois que le démarrage de l'application et de l'est de l' .NET version connecteur 6.6.5.0 (mais j'imagine que c'est bon pour les autres versions.)

string dataProvider = @"MySql.Data.MySqlClient";
string dataProviderDescription = @".Net Framework Data Provider for MySQL";
string dataProviderName = @"MySQL Data Provider";
string dataProviderType = @"MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.6.5.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d";

bool addProvider = true;
var dataSet = ConfigurationManager.GetSection("system.data") as DataSet;
foreach (DataRow row in dataSet.Tables[0].Rows)
{
    if ((row["InvariantName"] as string) == dataProvider)
    {
        // it is already in the config, no need to add.
        addProvider = false;
        break;
    }
}

if (addProvider)
    dataSet.Tables[0].Rows.Add(dataProviderName, dataProviderDescription, dataProvider, dataProviderType);

Mise à jour pour EF 6.0+

Vous pouvez ajouter un DbProviderFactory par l'enregistrement d'un IDbDependencyResolver et de résolution pour le type DbProviderFactory. Un exemple de ceci est ci-dessous:

static class Program
{
    [STAThread]
    static void Main()
    {
        System.Data.Entity.DbConfiguration.Loaded += (_, a) => {
            a.AddDependencyResolver(new MyDependencyResolver(), true);
        };  

        Application.Run(new Form1());
    }
}

class MyDependencyResolver : System.Data.Entity.Infrastructure.DependencyResolution.IDbDependencyResolver {

    public object GetService(Type type, object key) {

        //Output the service attempting to be resolved along with it's key 
        System.Diagnostics.Debug.WriteLine(string.Format("MyDependencyResolver.GetService({0}, {1})", type.Name, key == null ? "" : key.ToString()));

        if (type == typeof(System.Data.Common.DbProviderFactory)) {

            //Return whatever DbProviderFactory is relevant
            return new MyDbProviderFactory(); 

        }else if(type == typeof(System.Data.Entity.Infrastructure.IProviderInvariantName) && key != null && key == "MyDbProviderFactory"){

            //Return the Provider's invariant name for the MyDbProviderFactory
            return new MyProviderInvariantName();

        }

        return null;
    }

    public IEnumerable<object> GetServices(Type type, object key) {
        return new object[] { GetService(type, key) }.ToList().Where(o => o != null);
    }
}

vous pourriez avoir à résoudre d'autres types de fonction de ce type de raisons, vous avez besoin de faire et comment votre projet d'installation. Fondamentalement, il suffit de commencer avec le code ci-dessus et continuer à déboguer jusqu'à ce que vous avez déterminé que tous les services dont vous avez besoin pour résoudre de vos besoins spécifiques.

Vous pouvez en lire plus à propos de EF de la résolution des dépendances sur les liens ci-dessous:

• http://msdn.microsoft.com/en-us/data/jj680697.aspx
• https://entityframework.codeplex.com/wikipage?title=EF%20Configuration%20and%20Extensibility
• https://entityframework.codeplex.com/wikipage?title=Rebuilding%20EF%20providers%20for%20EF6

En outre, vous pouvez faire cette configuration en remplaçant DbConfiguration comme décrit dans le premier lien ci-dessus.

Dans .NET de Base 2.1 et version ultérieure, vous pouvez utiliser DbProviderFactories.RegisterFactory de programmation pour enregistrer un DbProviderFactory.

Même Plus Tard, La Réponse

L'obtenir à l'aide de configuration comme ci-dessus. J'ai trouvé que cela semble exiger que le fournisseur de l'assemblée pour être quelque part que le programme en cours d'exécution peut le trouver.

    /// <summary>
/// Creates a DbProviderFactory instance without needing configuration file
/// </summary>
/// <param name="lsProviderName">Name of the provider.  Like "System.Data.SQLite"</param>
/// <param name="lsClass">Class and assembly information.  Like "System.Data.SQLite.SQLiteFactory, System.Data.SQLite"</param>
/// <returns>A specific DbProviderFactory instance, or null if one can't be found</returns>
protected static DbProviderFactory GetDbProviderFactoryFromConfigRow(string lsProviderName, string lsClass)
{
if (string.Empty != lsProviderName && string.Empty != lsClass)
{
DataRow loConfig = null;
DataSet loDataSet = ConfigurationManager.GetSection("system.data") as DataSet;
foreach (DataRow loRow in loDataSet.Tables[0].Rows)
{
if ((loRow["InvariantName"] as string) == lsProviderName)
{
loConfig = loRow;
}
}
if (null == loConfig)
{
loConfig = loDataSet.Tables[0].NewRow();
loConfig["InvariantName"] = lsProviderName;
loConfig["Description"] = "Dynamically added";
loConfig["Name"] = lsProviderName + "Name";
loConfig["AssemblyQualifiedName"] = lsClass;
loDataSet.Tables[0].Rows.Add(loConfig);
}
try
{
DbProviderFactory loDbProviderFactoryByRow = DbProviderFactories.GetFactory(loConfig);
return loDbProviderFactoryByRow;
}
catch (Exception loE)
{
//// Handled exception if needed, otherwise, null is returned and another method can be tried.
}
}

Une autre méthode qui obtient le champ d'Instance directement à partir de l'assemblée. Il fonctionne même lorsque la DLL est quelque part d'autre sur le système.

    /// <summary>
/// Creates a DbProviderFactory instance without needing configuration file
/// </summary>
/// <param name="lsClass">Class and assembly information.  Like "System.Data.SQLite.SQLiteFactory, System.Data.SQLite"</param>
/// <param name="lsAssemblyFile">Full path to the assembly DLL. Like "c:\references\System.Data.SQLite.dll"</param>
/// <returns>A specific DbProviderFactory instance, or null if one can't be found</returns>
protected static DbProviderFactory GetDbProviderFactoryFromAssembly(string lsClass, string lsAssemblyFile)
{
if (lsAssemblyFile != string.Empty && lsClass != string.Empty)
{
Assembly loAssembly = System.Reflection.Assembly.LoadFrom(lsAssemblyFile);
if (null != loAssembly)
{
string[] laAssembly = lsClass.Split(new char[] { ',' });
Type loType = loAssembly.GetType(laAssembly[0].Trim());
FieldInfo loInfo = loType.GetField("Instance");
if (null != loInfo)
{
object loInstance = loInfo.GetValue(null);
if (null != loInstance)
{
if (loInstance is System.Data.Common.DbProviderFactory)
{
return loInstance as DbProviderFactory;
}
}
}
}
}
return null;
}