private DbConfiguration(string providerName, string connectionString, DbProviderFactory dbProviderFactory)
 {
     this.providerName = providerName;
     this.connectionString = connectionString;
     this.dbProviderFactory = dbProviderFactory;
     this.dbDriver = currentDbDrivers[providerName];
 }

 // SchemaReader.ReadSchema
 public override Tables ReadSchema(DbConnection connection, DbProviderFactory factory)
 {
     var result=new Tables();	
     this._connection=connection;
     this._factory=factory;
     var cmd=this._factory.CreateCommand();        
     cmd.Connection=connection;
     cmd.CommandText=TABLE_SQL;
     //cmd.GetType().GetProperty("BindByName").SetValue(cmd, true, null);
     //pull the tables in a reader
     using(cmd)
     {
         using (var rdr=cmd.ExecuteReader())
         {
             while(rdr.Read())
             {
                 Table tbl=new Table();
                 tbl.Name=rdr["name"].ToString();
                 tbl.Schema = "";
                 tbl.IsView=String.Compare(rdr["type"].ToString(), "view", true)==0;
                 tbl.CleanName=CleanUp(tbl.Name);
                 tbl.ClassName=Inflector.MakeSingular(tbl.CleanName);
                 tbl.SQL = rdr["sql"].ToString();
                 result.Add(tbl);
             }
         }
     }
     foreach (var tbl in result)
     {
         tbl.Columns=this.LoadColumns(tbl);
         tbl.Indexes = this.LoadIndices(tbl.Name);
         tbl.ForeignKeys = this.LoadForeignKeys(tbl.Name);
     }
     return result;
 }

		public static bool CheckMembershipSchemaVersion (DbProviderFactory factory, string connStr, string feature, string compatibleVersion)
		{
			using (DbConnection connection = CreateConnection (factory, connStr)) {
				DbCommand command = factory.CreateCommand ();
				command.Connection = connection;
				command.CommandText = @"aspnet_CheckSchemaVersion";
				command.CommandType = CommandType.StoredProcedure;

				AddParameter (factory, command, "@Feature", ParameterDirection.Input, feature);
				AddParameter (factory, command, "@CompatibleSchemaVersion", ParameterDirection.Input, compatibleVersion);
				DbParameter returnValue = AddParameter (factory, command, "@ReturnVal", ParameterDirection.ReturnValue, null);

				try {
					command.ExecuteNonQuery ();
				}
				catch (Exception) {
					throw new ProviderException ("ASP.NET Membership schema not installed.");
				}

				if ((int) (returnValue.Value ?? -1) == 0)
					return true;

				return false;
			}
		}

        private static async Task<IEnumerable<Fortune>> LoadRows(string connectionString, DbProviderFactory dbProviderFactory)
        {
            var result = new List<Fortune>();

            using (var db = dbProviderFactory.CreateConnection())
            using (var cmd = db.CreateCommand())
            {
                cmd.CommandText = "SELECT [Id], [Message] FROM [Fortune]";

                db.ConnectionString = connectionString;
                await db.OpenAsync();

                using (var rdr = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection))
                {
                    while (await rdr.ReadAsync())
                    {
                        result.Add(new Fortune
                        {
                            Id = rdr.GetInt32(0),
                            Message = rdr.GetString(1)
                        });
                    }
                }
            }

            result.Add(new Fortune { Message = "Additional fortune added at request time." });
            result.Sort();

            return result;
        }

 private FindByUserDatabase(IRepositoryContext context, DbProviderFactory providerFactory, string connectionString)
 {
     Context = context;
     ProviderFactory = providerFactory;
     ConnectionString = connectionString;
     Connection = GetConnection();
 }

        internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
        {
            DebugCheck.NotNull(storeProviderFactory);
            DebugCheck.NotNull(commandTree);

            return new EntityCommandDefinition(storeProviderFactory, commandTree);
        }

 public CachedFactory(DbProviderFactory factory, string factoryName, string factoryDescription, string factoryAssemblyQualifiedNameKey)
 {
     Factory = factory;
     FactoryName = factoryName;
     FactoryDescription = factoryDescription;
     FactoryAssemblyQualifiedNameKey = factoryAssemblyQualifiedNameKey;
 }

 public ProxyDbConnection(DbConnection proxiedConnection, DbProviderFactory proxiedFactory)
 {
     ProxiedConnection = proxiedConnection;
     ProxiedFactory = proxiedFactory;
     Context = GetContext(this);
     Guid = System.Guid.NewGuid().ToString();
 }

 public DataAccess(DbProviderFactory factory, string connectionString, string provider, int? commandTimeout)
 {
     _factory = factory;
     _provider = provider;
     _commandTimeout = commandTimeout;
     _connection = GetConnection(connectionString);
 }

        internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
        {
            //Contract.Requires(storeProviderFactory != null);
            //Contract.Requires(commandTree != null);

            return new EntityCommandDefinition(storeProviderFactory, commandTree);
        }

        protected DbProvider(string connectionString, System.Data.Common.DbProviderFactory dbProviderFactory)
        {
            this.dbConnectionStringBuilder = new DbConnectionStringBuilder();
            this.dbConnectionStringBuilder.ConnectionString = connectionString;
            this.dbProviderFactory = dbProviderFactory;

        }

        internal static DbProviderServices GetProviderServices(DbProviderFactory factory)
        {
            EDesignUtil.CheckArgumentNull(factory, "factory");

            // Special case SQL client so that it will work with System.Data from .NET 4.0 even without
            // a binding redirect.
            if (factory is SqlClientFactory)
            {
                return SqlProviderServices.Instance;
            }

            IServiceProvider serviceProvider = factory as IServiceProvider;
            if (serviceProvider == null)
            {
                throw MetadataUtil.ProviderIncompatible(System.Data.Entity.Design.Strings.EntityClient_DoesNotImplementIServiceProvider(
                    factory.GetType().ToString()));
            }

            DbProviderServices providerServices = serviceProvider.GetService(typeof(DbProviderServices)) as DbProviderServices;
            if (providerServices == null)
            {
                throw MetadataUtil.ProviderIncompatible(
                    System.Data.Entity.Design.Strings.EntityClient_ReturnedNullOnProviderMethod(
                        "GetService",
                        factory.GetType().ToString()));
            }
            return providerServices;
        }

 public SqlWriterCommonTest(SqlType sqlType, DatabaseTable table, DbProviderFactory factory, string connectionString)
 {
     _connectionString = connectionString;
     _factory = factory;
     _table = table;
     _sqlType = sqlType;
 }

        public SQLQueryProvider(DbProviderFactory dbFactory, string dbConnStr, string tableName, SetterDelegate setter) {

            m_dbFactory = dbFactory;
            m_dbConnStr = dbConnStr;
            m_tableName = tableName;
            m_setter = setter;
        }

        private static object CreateObject(DbProviderFactory factory, ProviderSupportedClasses kindOfObject, string providerName)
        {
            switch (kindOfObject)
            {
                case ProviderSupportedClasses.DbConnection:
                    return factory.CreateConnection();

                case ProviderSupportedClasses.DbDataAdapter:
                    return factory.CreateDataAdapter();

                case ProviderSupportedClasses.DbParameter:
                    return factory.CreateParameter();

                case ProviderSupportedClasses.DbCommand:
                    return factory.CreateCommand();

                case ProviderSupportedClasses.DbCommandBuilder:
                    return factory.CreateCommandBuilder();

                case ProviderSupportedClasses.DbDataSourceEnumerator:
                    return factory.CreateDataSourceEnumerator();

                case ProviderSupportedClasses.CodeAccessPermission:
                    return factory.CreatePermission(PermissionState.None);
            }
            throw new InternalException(string.Format(CultureInfo.CurrentCulture, "Cannot create object of provider class identified by enum {0} for provider {1}", new object[] { Enum.GetName(typeof(ProviderSupportedClasses), kindOfObject), providerName }));
        }

        private static async Task<World> LoadRow(string connectionString, DbProviderFactory dbProviderFactory)
        {
            using (var db = dbProviderFactory.CreateConnection())
            using (var cmd = db.CreateCommand())
            {
                cmd.CommandText = "SELECT [Id], [RandomNumber] FROM [World] WHERE [Id] = @Id";
                var id = cmd.CreateParameter();
                id.ParameterName = "@Id";
                id.DbType = DbType.Int32;
                id.Value = _random.Next(1, 10001);
                cmd.Parameters.Add(id);

                db.ConnectionString = connectionString;
                await db.OpenAsync();

                using (var rdr = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection))
                {
                    await rdr.ReadAsync();

                    return new World
                    {
                        Id = rdr.GetInt32(0),
                        RandomNumber = rdr.GetInt32(1)
                    };
                }
            }
        }

        public AdoResponseCache(DbProviderFactory factory, string connectionString)
        {
            _factory = factory;
            _connectionString = connectionString;

            EnsureTableExists();
        }

 internal StubDataMapper(DbProviderFactory dbfactory, DbCommand command, DbConnection connection, DbParameterCollection parameters)
     : base(dbfactory, "connection string") 
 {
     _command = command;
     _connection = connection;
     _parameters = parameters;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DatabaseManager"/> class.
 /// </summary>
 /// <param name="connectionProvider">The connection provider.</param>
 /// <param name="providerName">Name of the provider.</param>
 public DatabaseManager(DbProvider provider, string connectionString)
 {
     string providerName = provider.GetEnumMemberValue();
     this.connectionProvider = DbProviderFactories.GetFactory(providerName);
     this.providerName = providerName;
     this.connectionString = connectionString;
 }

 /// <summary>Instancia a DbFactory "setando a string de conexao"
 /// </summary>
 public DAOFactory(string connectionStringValue, string provider)
 {
     AppSettingsReader apps = new AppSettingsReader();
     objProvider = DbProviderFactories.GetFactory(provider);
     connectionString = connectionStringValue;
     objConn = objProvider.CreateConnection();
 }