public void Correct_services_are_returned_when_setup_by_replacing_ADO_NET_provider()
{
RegisterAdoNetProvider(typeof(WrappingAdoNetProvider <SqlClientFactory>));
MutableResolver.AddResolver <DbProviderServices>(k => WrappingEfProvider <SqlClientFactory, SqlProviderServices> .Instance);
#if NETSTANDARD
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbProviderFactoriesCore.GetFactory(SqlClientInvariantName));
#else
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbProviderFactories.GetFactory(SqlClientInvariantName));
#endif
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbConfiguration.DependencyResolver.GetService <DbProviderFactory>(SqlClientInvariantName));
Assert.Same(
WrappingEfProvider <SqlClientFactory, SqlProviderServices> .Instance,
DbConfiguration.DependencyResolver.GetService <DbProviderServices>(SqlClientInvariantName));
Assert.Equal(
SqlClientInvariantName,
DbConfiguration.DependencyResolver.GetService <IProviderInvariantName>(WrappingAdoNetProvider <SqlClientFactory> .Instance).Name);
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbConfiguration.DependencyResolver.GetService <IDbProviderFactoryResolver>()
.ResolveProviderFactory(new WrappingConnection <SqlClientFactory>(new SqlConnection())));
}
private static object GetService(Type type, object key, Func <ArgumentException, string, object> handleFailedLookup)
{
if (type == typeof(DbProviderFactory))
{
var name = key as string;
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException(Strings.DbDependencyResolver_NoProviderInvariantName(typeof(DbProviderFactory).Name));
}
try
{
#if NETSTANDARD
return(DbProviderFactoriesCore.GetFactory(name));
#else
return(DbProviderFactories.GetFactory(name));
#endif
}
catch (ArgumentException e)
{
return(handleFailedLookup(e, name));
}
}
return(null);
}
public static string GetProviderInvariantName(this DbProviderFactory factory)
{
DebugCheck.NotNull(factory);
const int invariantNameIndex = 2;
#if NETSTANDARD
var dataRows = DbProviderFactoriesCore.GetFactoryClasses().Rows.OfType <DataRow>();
var row = new ProviderRowFinder().FindRow(
factory.GetType(),
r => DbProviderFactoriesCore.GetFactory(r).GetType() == factory.GetType(),
dataRows);
#else
var dataRows = DbProviderFactories.GetFactoryClasses().Rows.OfType <DataRow>();
var row = new ProviderRowFinder().FindRow(
factory.GetType(),
r => DbProviderFactories.GetFactory(r).GetType() == factory.GetType(),
dataRows);
#endif
if (row == null)
{
throw new NotSupportedException(Strings.ProviderNameNotFound(factory));
}
return((string)row[invariantNameIndex]);
}
public DbProviderFactory GetProviderFactory(DbConnection connection, IEnumerable <DataRow> dataRows)
{
DebugCheck.NotNull(connection);
DebugCheck.NotNull(dataRows);
var connectionType = connection.GetType();
return(_cache.GetOrAdd(
connectionType,
t =>
{
var row = _finder.FindRow(t, r => ExactMatch(r, t), dataRows)
?? _finder.FindRow(null, r => ExactMatch(r, t), dataRows)
?? _finder.FindRow(t, r => AssignableMatch(r, t), dataRows)
?? _finder.FindRow(null, r => AssignableMatch(r, t), dataRows);
if (row == null)
{
throw new NotSupportedException(Strings.ProviderNotFound(connection.ToString()));
}
#if NETSTANDARD
return DbProviderFactoriesCore.GetFactory(row);
#else
return DbProviderFactories.GetFactory(row);
#endif
}));
}
public static void Initialize()
{
// TODO: ZZZ - Can we remove this?
#if NETSTANDARD
DbProviderFactoriesCore.RegisterFactory("System.Data.FakeSqlClient", FakeSqlProviderFactory.Instance);
#endif
// Does nothing but ensures that the singleton instance has been created.
}
internal static void Run()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
DbProviderFactoriesCore.RegisterFactory("System.Data.SqlClient", SqlClientFactory.Instance);
DbProviderFactoriesCore.RegisterFactory("System.Data.SqlServerCe.3.5", SqlCeProviderFactory.Instance);
DbProviderFactoriesCore.RegisterFactory("System.Data.SqlServerCe.4.0", SqlCeProviderFactory.Instance);
}
public DbProviderFactory ResolveProviderFactory(DbConnection connection)
{
Check.NotNull(connection, "connection");
#if NETSTANDARD
return(GetProviderFactory(connection, DbProviderFactoriesCore.GetFactoryClasses().Rows.OfType <DataRow>()));
#else
return(GetProviderFactory(connection, DbProviderFactories.GetFactoryClasses().Rows.OfType <DataRow>()));
#endif
}
public DbProviderFactory ResolveProviderFactory(DbConnection connection)
{
Check.NotNull(connection, "connection");
#if NETSTANDARD
return(DbProviderFactoriesCore.GetFactory(connection));
#else
return(DbProviderFactories.GetFactory(connection));
#endif
}
/// <summary>
/// Returns the <see cref="DbProviderFactory"/> for the given connection.
/// </summary>
/// <param name="connection">The database connection.</param>
/// <returns>The provider factory for the connection.</returns>
public DbProviderFactory ResolveProviderFactory(DbConnection connection)
{
#if NET_45_OR_GREATER
return(DbProviderFactories.GetFactory(connection));
#elif NETSTANDARD
return(DbProviderFactoriesCore.GetFactory(connection));
#else
return(DbProviderFactories.GetFactory(MySqlProviderInvariantName.ProviderName));
#endif
}
public static DbConnection CreateConnection(string providerInvariantName)
{
#if NETSTANDARD && !EF6
DbProviderFactory factory = DbProviderFactoriesCore.GetFactory(providerInvariantName);
#else
DbProviderFactory factory = DbProviderFactories.GetFactory(providerInvariantName);
#endif
return(factory.CreateConnection());
}
private static bool AssignableMatch(DataRow row, Type connectionType)
{
DebugCheck.NotNull(row);
DebugCheck.NotNull(connectionType);
#if NETSTANDARD
return(connectionType.IsInstanceOfType(DbProviderFactoriesCore.GetFactory(row).CreateConnection()));
#else
return(connectionType.IsInstanceOfType(DbProviderFactories.GetFactory(row).CreateConnection()));
#endif
}
private static bool ExactMatch(DataRow row, Type connectionType)
{
DebugCheck.NotNull(row);
DebugCheck.NotNull(connectionType);
#if NETSTANDARD
return(DbProviderFactoriesCore.GetFactory(row).CreateConnection().GetType() == connectionType);
#else
return(DbProviderFactories.GetFactory(row).CreateConnection().GetType() == connectionType);
#endif
}
private static void RegisterAdoNetProvider(Type providerFactoryType)
{
DbProviderFactoriesCore.RegisterFactory(SqlClientInvariantName, providerFactoryType);
//var row = _providerTable.NewRow();
//row["Name"] = "SqlClient Data Provider";
//row["Description"] = ".Net Framework Data Provider for SqlServer";
//row["InvariantName"] = SqlClientInvariantName;
//row["AssemblyQualifiedName"] = providerFactoryType.AssemblyQualifiedName;
//_providerTable.Rows.Remove(_providerTable.Rows.Find(SqlClientInvariantName));
//_providerTable.Rows.Add(row);
}
private GenericProviderFactory()
{
DbProviderFactoriesCore.RegisterFactory("My.Generic.Provider.DbProviderFactory", this);
//var providerTable =
// (DataTable)
// typeof(DbProviderFactories).GetOnlyDeclaredMethod("GetProviderTable").Invoke(null, null);
//var row = providerTable.NewRow();
//row["Name"] = "GenericProviderFactory";
//row["InvariantName"] = InvariantProviderName;
//row["Description"] = "Fake GenericProviderFactory";
//row["AssemblyQualifiedName"] = GetType().AssemblyQualifiedName;
//providerTable.Rows.Add(row);
}
private static void RegisterAdoNetProvider(Type providerFactoryType)
{
#if NETSTANDARD
// TODO: ZZZ - Restore old way to register?
DbProviderFactoriesCore.RegisterFactory(SqlClientInvariantName, providerFactoryType);
#else
var row = _providerTable.NewRow();
row["Name"] = "SqlClient Data Provider";
row["Description"] = ".Net Framework Data Provider for SqlServer";
row["InvariantName"] = SqlClientInvariantName;
row["AssemblyQualifiedName"] = providerFactoryType.AssemblyQualifiedName;
_providerTable.Rows.Remove(_providerTable.Rows.Find(SqlClientInvariantName));
_providerTable.Rows.Add(row);
#endif
}
internal static void VerifyProvider()
{
try
{
#if NETSTANDARD
DbProviderFactoriesCore.GetFactory(ProviderInvariantName);
#else
DbProviderFactories.GetFactory(ProviderInvariantName);
#endif
}
catch (Exception ex)
{
throw new EffortException(
ExceptionMessages.AutomaticRegistrationFailed,
ex);
}
}
private GenericProviderFactory()
{
// TODO: ZZZ - It's normal way or we should change it?
#if NETSTANDARD
DbProviderFactoriesCore.RegisterFactory("My.Generic.Provider.DbProviderFactory", this);
#else
var providerTable =
(DataTable)
typeof(DbProviderFactories).GetOnlyDeclaredMethod("GetProviderTable").Invoke(null, null);
var row = providerTable.NewRow();
row["Name"] = "GenericProviderFactory";
row["InvariantName"] = InvariantProviderName;
row["Description"] = "Fake GenericProviderFactory";
row["AssemblyQualifiedName"] = GetType().AssemblyQualifiedName;
providerTable.Rows.Add(row);
#endif
}
public void Correct_services_are_returned_when_wrapping_setup_at_EF_level_only()
{
WrappingAdoNetProvider <SqlClientFactory> .WrapProviders();
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbConfiguration.DependencyResolver.GetService <DbProviderFactory>(SqlClientInvariantName));
Assert.Same(
WrappingEfProvider <SqlClientFactory, SqlProviderServices> .Instance,
DbConfiguration.DependencyResolver.GetService <DbProviderServices>(SqlClientInvariantName));
Assert.Equal(
SqlClientInvariantName,
DbConfiguration.DependencyResolver.GetService <IProviderInvariantName>(WrappingAdoNetProvider <SqlClientFactory> .Instance).Name);
Assert.Same(
WrappingAdoNetProvider <SqlClientFactory> .Instance,
DbConfiguration.DependencyResolver.GetService <IDbProviderFactoryResolver>()
.ResolveProviderFactory(new WrappingConnection <SqlClientFactory>(new SqlConnection())));
// Should still report what is in the providers table
Assert.Same(SqlClientFactory.Instance, DbProviderFactoriesCore.GetFactory(SqlClientInvariantName));
}
// TODO: ZZZ - Can we remove this?
#if NETSTANDARD
static FakeSqlProviderServices()
{
DbProviderFactoriesCore.RegisterFactory("System.Data.FakeSqlClient", FakeSqlProviderFactory.Instance);
}
static FakeSqlConnection()
{
DbProviderFactoriesCore.RegisterFactory("System.Data.FakeSqlClient", FakeSqlProviderFactory.Instance);
}
public static void Initialize()
{
DbProviderFactoriesCore.RegisterFactory("System.Data.FakeSqlClient", FakeSqlProviderFactory.Instance);
// Does nothing but ensures that the singleton instance has been created.
}
public DbProviderFactory ResolveProviderFactory(DbConnection connection)
{
Check.NotNull(connection, "connection");
return(DbProviderFactoriesCore.GetFactory(connection));
}
