C# DbProviderFactory.CreateDataAdapter方法代码示例

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

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

		public TableAdapterSchemaInfo (DbProviderFactory provider) {
			this.Provider = provider;
			this.Adapter = provider.CreateDataAdapter ();
			this.Connection = provider.CreateConnection ();
			this.Commands = new ArrayList ();
			this.ShortCommands = false;
		}

        public ConnexionOracle()
        {
            connec = new OracleConnection();
            connec.ConnectionString = string.Format("User Id=om141055; Password=om141055; Data Source=//{0}", Properties.Settings.Default.connexion);
            dbpf = DbProviderFactories.GetFactory("Oracle.DataAccess.Client");
            connec.Open();

            // initialisation de la connexion conn et de dbpf
            dba = dbpf.CreateDataAdapter();
        }

    //Constructor: intiliazes dbfactory and its connection
    public DALBlog(string connectionString)
    {
        // set object connection string to the one provided
        this.connectionString = ConfigurationManager.ConnectionStrings[connectionString].ConnectionString;

        // create new factory based on provider
        dbFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");

        // create a connection to the desired database
        connection = dbFactory.CreateConnection();
        connection.ConnectionString = this.connectionString;

        // initialize DataSet and DataAdapter objects
        ds = new DataSet();
        da = dbFactory.CreateDataAdapter();
    }

 public static DataTable ExecuteScalar(string tableName,
                                       string connectionString,
                                       string command,
                                       DbProviderFactory dbFactory)
 {
     DataTable dtTable = CreateDataTable(tableName);
     using (DbConnection dbConnection = dbFactory.CreateConnection()) {
         dbConnection.ConnectionString = connectionString;
         dbConnection.Open();
         using (DbDataAdapter dbAdapter = dbFactory.CreateDataAdapter()) {
             dbAdapter.SelectCommand = dbConnection.CreateCommand();
             dbAdapter.SelectCommand.CommandText = command;
             dbAdapter.Fill(dtTable);
         }
     }
     return dtTable;
 }

        /// <summary>
        /// 创建数据集
        /// </summary>
        /// <param name="dbProvider">数据库提供者</param>
        /// <param name="dbCommand">数据库命令</param>
        /// <param name="tableNames">数据表名称</param>
        /// <returns>数据集</returns>
        internal static DataSet InternalCreateDataSet(DbProviderFactory dbProvider, DbCommand dbCommand, String[] tableNames)
        {
            DataSet dataSet = new DataSet();
            dataSet.Locale = CultureInfo.InvariantCulture;

            using (DbDataAdapter dataAdapter = dbProvider.CreateDataAdapter())
            {
                ((IDbDataAdapter)dataAdapter).SelectCommand = dbCommand;
                String text = "Table";

                for (Int32 j = 0; j < tableNames.Length; j++)
                {
                    String sourceTable = (j == 0) ? text : (text + j);
                    dataAdapter.TableMappings.Add(sourceTable, tableNames[j]);
                }

                dataAdapter.Fill(dataSet);
            }

            return dataSet;
        }

        // Utilizes the SQLiteCommandBuilder,
        // which in turn utilizes SQLiteDataReader's GetSchemaTable() functionality
        // This insert is slow because it must raise callbacks before and after every update.
        // For a fast update, see the FastInsertMany function beneath this one
        internal static void DataAdapter(DbProviderFactory fact, DbConnection cnn, bool bWithIdentity)
        {
            using (DbTransaction dbTrans = cnn.BeginTransaction())
              {
            using (DbDataAdapter adp = fact.CreateDataAdapter())
            {
              using (DbCommand cmd = cnn.CreateCommand())
              {
            cmd.Transaction = dbTrans;
            cmd.CommandText = "SELECT * FROM TestCase WHERE 1 = 2";
            adp.SelectCommand = cmd;

            using (DbCommandBuilder bld = fact.CreateCommandBuilder())
            {
              bld.DataAdapter = adp;
              using (adp.InsertCommand = (DbCommand)((ICloneable)bld.GetInsertCommand()).Clone())
              {
                if (bWithIdentity)
                {
                  adp.InsertCommand.CommandText += ";SELECT last_insert_rowid() AS [ID]";
                  adp.InsertCommand.UpdatedRowSource = UpdateRowSource.FirstReturnedRecord;
                }
                bld.DataAdapter = null;

                using (DataTable tbl = new DataTable())
                {
                  adp.Fill(tbl);
                  for (int n = 0; n < 10000; n++)
                  {
                    DataRow row = tbl.NewRow();
                    row[1] = n + (50000 * ((bWithIdentity == true) ? 2 : 1));
                    tbl.Rows.Add(row);
                  }

                  Console.WriteLine(String.Format("          Inserting using CommandBuilder and DataAdapter\r\n          ->{0} (10,000 rows) ...", (bWithIdentity == true) ? "(with identity fetch)" : ""));
                  int dtStart = Environment.TickCount;
                  adp.Update(tbl);
                  int dtEnd = Environment.TickCount;
                  dtEnd -= dtStart;
                  Console.Write(String.Format("          -> Insert Ends in {0} ms ... ", (dtEnd)));

                  dtStart = Environment.TickCount;
                  dbTrans.Commit();
                  dtEnd = Environment.TickCount;
                  dtEnd -= dtStart;
                  Console.WriteLine(String.Format("Commits in {0} ms", (dtEnd)));
                }
              }
            }
              }
            }
              }
        }

        private static void XML2DB(DbProviderFactory dataFactory, DbConnection dbcn, DbTransaction tran, DTDatabase dtDatabase, string namespacePrefix, string namespaceUri, XPathDocument genericXMLDate, XPathDocument formData, XPathDocument resultData, string prodef_id, string project_id, DateTime? applyingDate, DateTime? finishedDate)
        {
            if (!string.IsNullOrEmpty(dtDatabase.BeforeProcedure))
            {
                if (LoggingService.IsInfoEnabled)
                {
                    LoggingService.InfoFormatted("执行交换前存储过程：{0}", new object[] { dtDatabase.BeforeProcedure });
                }
                DbCommand command = dbcn.CreateCommand();
                command.CommandText = dtDatabase.BeforeProcedure;
                command.CommandType = CommandType.StoredProcedure;
                command.Transaction = tran;
                command.ExecuteNonQuery();
            }
            XPathDocument[] documents = new XPathDocument[] { formData, resultData, genericXMLDate };
            foreach (DTTable table in dtDatabase.DTTables)
            {
                XPathDocument document;
                if (!table.IsActive || !table.IfImport)
                {
                    continue;
                }
                if (LoggingService.IsInfoEnabled)
                {
                    LoggingService.InfoFormatted("准备交换数据至表：'{0}<{1}>'", new object[] { table.Name, table.Description });
                }
                if (LoggingService.IsDebugEnabled)
                {
                    LoggingService.DebugFormatted("基础数据来自：{0}", new object[] { table.SourceType });
                }
                switch (table.SourceType)
                {
                    case SourceType.FormData:
                        document = formData;
                        break;

                    case SourceType.ResultData:
                        document = resultData;
                        break;

                    case SourceType.GenericXMLData:
                        document = genericXMLDate;
                        break;

                    default:
                        throw new NotSupportedException(string.Format("尚不支持的类型:{0}！", table.SourceType));
                }
                if (document != null)
                {
                    DbDataAdapter adapter = dataFactory.CreateDataAdapter();
                    DbCommand command2 = dbcn.CreateCommand();
                    command2.Transaction = tran;
                    command2.CommandText = string.Format("select * from {0} where 1<>1", string.IsNullOrEmpty(table.ImportToTable) ? table.Name : table.ImportToTable);
                    adapter.SelectCommand = command2;
                    DbCommandBuilder builder = dataFactory.CreateCommandBuilder();
                    builder.DataAdapter = adapter;
                    adapter.InsertCommand = builder.GetInsertCommand();
                    adapter.InsertCommand.Transaction = tran;
                    XPathNavigator navigator = document.CreateNavigator();
                    XPathNodeIterator iterator = null;
                    if (!string.IsNullOrEmpty(namespacePrefix) && !string.IsNullOrEmpty(namespaceUri))
                    {
                        table.NamespacePrefix = string.Format(table.NamespacePrefix, namespacePrefix);
                        table.NamespaceUri = string.Format(table.NamespaceUri, namespaceUri);
                        table.MapXMLElementName = string.Format(table.MapXMLElementName, namespacePrefix);
                    }
                    if (!string.IsNullOrEmpty(table.NamespacePrefix))
                    {
                        if (LoggingService.IsDebugEnabled)
                        {
                            LoggingService.DebugFormatted("搜索:'{0}',前缀:'{1}',命名空间:'{2}'", new object[] { table.MapXMLElementName, table.NamespacePrefix, table.NamespaceUri });
                        }
                        XmlNamespaceManager resolver = new XmlNamespaceManager(navigator.NameTable);
                        resolver.AddNamespace(table.NamespacePrefix, table.NamespaceUri);
                        iterator = navigator.Select(table.MapXMLElementName, resolver);
                        if ((iterator.Count == 0) && !string.IsNullOrEmpty(table.DataSetName))
                        {
                            if (LoggingService.IsDebugEnabled)
                            {
                                LoggingService.DebugFormatted("搜索:'/{0}:{1}/{2}'", new object[] { namespacePrefix, table.DataSetName, table.MapXMLElementName });
                            }
                            iterator = navigator.Select(string.Format("/{0}:{1}/{2}", namespacePrefix, table.DataSetName, table.MapXMLElementName), resolver);
                        }
                    }
                    else
                    {
                        iterator = navigator.Select(table.MapXMLElementName);
                    }
                    if (iterator.Count > 0)
                    {
                        DataTable dataTable = new DataTable();
                        adapter.Fill(dataTable);
                        foreach (XPathNavigator navigator2 in iterator)
                        {
                            DataRow row = dataTable.NewRow();
                            foreach (DTColumn column in table.DTColumns)
                            {
                                if (!column.IsActive || !column.IfImport)
                                {
                                    continue;
//.........这里部分代码省略.........

 internal static DbDataAdapter CreateDataAdapter(DbProviderFactory factory, DbCommand command)
 {
     DbDataAdapter adapter = factory.CreateDataAdapter();
     ((IDbDataAdapter) adapter).SelectCommand = command;
     return adapter;
 }

        /// <summary>
        /// Creates data adapter for specifided database connection.
        /// </summary>
        /// <param name="factory">Database provider factory.</param>
        /// <returns>Created Relatived data adapter.</returns>
        private static DbDataAdapter _CreateDataAdapter(DbProviderFactory factory)
        {
            Debug.Assert(null != factory); // created

            DbDataAdapter adapter = factory.CreateDataAdapter();
            return adapter;
        }

 /// <summary>
 /// 返回DataTable
 /// </summary>
 /// <param name="dbTransaction"></param>
 /// <param name="commandType"></param>
 /// <param name="commandText"></param>
 /// <param name="commandParameters"></param>
 /// <returns></returns>
 public static DataTable ExecuteDataTable(DbProviderFactory factory, DbTransaction dbTransaction, CommandType commandType, string commandText, params DbParameter[] commandParameters)
 {
     if (dbTransaction == null)
     {
         throw new ArgumentNullException("dbTransaction");
     }
     if (dbTransaction != null && dbTransaction.Connection == null)
     {
         throw new ArgumentNullException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
     }
     using (DbCommand dbCommand = factory.CreateCommand())
     {
         PrepareCommand(dbCommand, dbTransaction.Connection, dbTransaction, commandType, commandText, commandParameters);
         using (DbDataAdapter da = factory.CreateDataAdapter())
         {
             da.SelectCommand = dbCommand;
             DataSet ds = new DataSet();
             da.Fill(ds);
             dbCommand.Parameters.Clear();
             DataTable dt = ds.Tables[0];
             return dt;
         }
     }
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="dbConnection"></param>
 /// <param name="commandType"></param>
 /// <param name="commandText"></param>
 /// <param name="commandParameters"></param>
 /// <returns></returns>
 public static DataSet ExecuteDataSet(DbProviderFactory factory, DbConnection dbConnection, CommandType commandType, string commandText, params DbParameter[] commandParameters)
 {
     if (dbConnection == null)
     {
         throw new ArgumentNullException("dbConnection");
     }
     using (DbCommand dbCommand = factory.CreateCommand())
     {
         PrepareCommand(dbCommand, dbConnection, (DbTransaction)null, commandType, commandText, commandParameters);
         using (DbDataAdapter da = factory.CreateDataAdapter())
         {
             da.SelectCommand = dbCommand;
             DataSet ds = new DataSet();
             da.Fill(ds);
             dbCommand.Parameters.Clear();
             return ds;
         }
     }
 }