C# DbProviderFactory.CreateConnection方法代码示例

        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 }));
        }

        protected void Initialize (string databaseName, string querySelectRowString)
        {
            string providerName = GetProviderNameByDBName(databaseName);
            string connectionString = GetConnectionStringByDBName(databaseName);

            // Create the DbProviderFactory and DbConnection.
            factory = DbProviderFactories.GetFactory(providerName);

            connection = factory.CreateConnection();
            connection.ConnectionString = connectionString;

            // Create the DbCommand.
            DbCommand SelectTableCommand = factory.CreateCommand();
            SelectTableCommand.CommandText = querySelectRowString;
            SelectTableCommand.Connection = connection;

            adapter = factory.CreateDataAdapter();
            adapter.SelectCommand = SelectTableCommand;

            // Create the DbCommandBuilder.
            builder = factory.CreateCommandBuilder();
            builder.DataAdapter = adapter;

            adapter.ContinueUpdateOnError = true;
        }

 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="dbConnectString">链接字符串</param>
 /// <param name="dbProviderNamespace">数据提供者的命名空间,例如:"System.Data.SqlClient"</param>
 public DBHelper(string dbConnectString, string dbProviderNamespace)
 {
     dbProviderFactory = DbProviderFactories.GetFactory(dbProviderNamespace);
     dbConnection = dbProviderFactory.CreateConnection();
     dbConnection.ConnectionString = dbConnectString;
     dbCommand = dbConnection.CreateCommand();
 }

        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;
        }

 /// <summary>
 /// 构造函数--重载方法二
 /// </summary>
 /// <param name="connectionstring">数据库链接</param>
 /// <param name="databasetype">数据库的类型</param>
 public DBHelper(string connectionstring, string databasetype)
 {
     MyFactory = DbProviderFactories.GetFactory(databasetype);
     MyConnection = MyFactory.CreateConnection();
     MyConnection.ConnectionString = (databasetype.ToString() == "System.Data.OleDb") ? ("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + GetDataPath(connectionstring) + ";") : (connectionstring);
     MyCommand = MyConnection.CreateCommand();
 }

 public DbBase(ConnObject co)
 {
     this.connObject = co;
     this.conn = co.Master.Conn;
     this.providerName = co.Master.ProviderName;
     dalType = co.Master.ConnDalType;
     _fac = GetFactory(providerName);
     _con = _fac.CreateConnection();
     _con.ConnectionString = DalCreate.FormatConn(dalType, conn);
     _com = _con.CreateCommand();
     if (_com != null)//Txt| Xml 时返回Null
     {
         _com.Connection = _con;
         _com.CommandTimeout = AppConfig.DB.CommandTimeout;
     }
     if (IsAllowRecordSql)//开启秒表计算
     {
         _watch = new Stopwatch();
     }
     //if (AppConfig.DB.LockOnDbExe && dalType == DalType.Access)
     //{
     //    string dbName = DataBase;
     //    if (!_dbOperator.ContainsKey(dbName))
     //    {
     //        try
     //        {
     //            _dbOperator.Add(dbName, false);
     //        }
     //        catch
     //        {
     //        }
     //    }
     //}
     //_com.CommandTimeout = 1;
 }

        /// <summary>
        ///	Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/>
        ///	instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method
        ///	returns null.
        /// </summary>
        /// <param name="db"></param>
        /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns>
        public static DbConnectionWrapper GetConnection(string connectionString, DbProviderFactory factory)
        {
            var currentTransaction = System.Transactions.Transaction.Current;

            if (currentTransaction == null)
            {
                return null;
            }

            var connectionList = _transactionConnections.GetOrAdd(currentTransaction, (t) =>
            {
                t.TransactionCompleted += OnTransactionCompleted; return new ConcurrentDictionary<string, DbConnectionWrapper>();
            });

            var connection = connectionList.GetOrAdd(connectionString, (s) =>
            {
                var dbConnection = factory.CreateConnection();
                dbConnection.ConnectionString = connectionString;
                dbConnection.Open();
                return new DbConnectionWrapper(dbConnection, factory);
            });

            connection.AddRef();
            return connection;
        }

    /// <summary>
    /// 构造函数
    /// </summary>
    public DBHelper(string providerName, string connectionString, string sqlType)
    {
        this._sqlType = sqlType;
        if (string.Compare(sqlType, "Mysql", true) == 0)
        {
            _connection = new MySqlConnection();
            _command = new MySqlCommand();
            this._paraPrefix = "?";
        }
        else
        {
            _provider = GetDbProvider(providerName);
            _connection = _provider.CreateConnection();
            _command = _provider.CreateCommand();
            if (string.Compare(sqlType, "Oracle", true) == 0)
            {
                this._paraPrefix = ":";
            }
            else if (string.Compare(sqlType, "SQLServer", true) == 0)
            {
                this._paraPrefix = "@";
            }
        }

        _connection.ConnectionString = connectionString;
        _command.Connection = _connection;
    }

        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 TableAdapterSchemaInfo (DbProviderFactory provider) {
			this.Provider = provider;
			this.Adapter = provider.CreateDataAdapter ();
			this.Connection = provider.CreateConnection ();
			this.Commands = new ArrayList ();
			this.ShortCommands = false;
		}

 //internal static IDbConnection CreateConnection(this DbProviderFactory factory,
 //                                               Action<IDbConnection> setup)
 //{
 //    IDbConnection connection = factory.CreateConnection();
 //    setup(connection);
 //    return connection;
 //}
 //internal static DbParameter CreateParameter(this DbProviderFactory factory,
 //                                            Action<DbParameter> setup)
 //{
 //    DbParameter parameter = factory.CreateParameter();
 //    setup(parameter);
 //    return parameter;
 //}
 //internal static DbCommand CreateCommand(this DbProviderFactory factory,
 //                                        Action<DbCommand> setup)
 //{
 //    DbCommand command = factory.CreateCommand();
 //    setup(command);
 //    return command;
 //}
 internal static IDbConnection CreateConnection(DbProviderFactory factory,
     Action<IDbConnection> setup)
 {
     IDbConnection connection = factory.CreateConnection();
     setup(connection);
     return connection;
 }

 /// <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();
 }

		static DbConnection CreateConnection (DbProviderFactory factory, string connStr)
		{
			DbConnection connection = factory.CreateConnection ();
			connection.ConnectionString = connStr;

			connection.Open ();
			return connection;
		}

        //public static DbConnection CreateConnection(this DbProviderFactory dbFactory, string connectionString)
        /// <summary>
        /// Create a DbConnection with the specified connection string set.
        /// </summary>
        public static DbConnection CreateConnection(DbProviderFactory dbFactory, string connectionString)
        {
            if (dbFactory == null) throw new ArgumentNullException("dbFactory");

            var connection = dbFactory.CreateConnection();
            connection.ConnectionString = connectionString;
            return connection;
        }

 public SQLEditor()
 {
     InitializeComponent();
     _providerFactory = DbProviderFactories.GetFactory("NuoDb.Data.Client");
     if (_providerFactory == null)
         throw new Exception("NuoDB Data Provider is not correctly registered");
     _connection = _providerFactory.CreateConnection();
 }