C# DbProviderFactory.CreateCommand方法代码示例

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

 internal static DbCommand CreateCommand(DbProviderFactory factory,
     Action<DbCommand> setup)
 {
     DbCommand command = factory.CreateCommand();
     setup(command);
     return command;
 }

        // SchemaReader.ReadSchema
        public override Tables ReadSchema(DbConnection connection, DbProviderFactory factory)
        {
            var result = new Tables();


            var cmd = factory.CreateCommand();
            cmd.Connection = connection;
            cmd.CommandText = TABLE_SQL;

            //pull the tables in a reader
            using (cmd)
            {
                using (var rdr = cmd.ExecuteReader())
                {
                    while (rdr.Read())
                    {
                        Table tbl = new Table();
                        tbl.Name = rdr["TABLE_NAME"].ToString();
                        tbl.Schema = rdr["TABLE_SCHEMA"].ToString();
                        tbl.IsView = String.Compare(rdr["TABLE_TYPE"].ToString(), "View", true) == 0;
                        tbl.CleanName = CleanUp(tbl.Name);
                        tbl.ClassName = Inflector.MakeSingular(tbl.CleanName);
                        result.Add(tbl);
                    }
                }
            }

            //this will return everything for the DB
            var schema = connection.GetSchema("COLUMNS");

            //loop again - but this time pull by table name
            foreach (var item in result)
            {
                item.Columns = new List<Column>();

                //pull the columns from the schema
                var columns = schema.Select("TABLE_NAME='" + item.Name + "'");
                foreach (var row in columns)
                {
                    var type = GetPropertyType(row);
                    Column col = new Column();
                    col.Name = row["COLUMN_NAME"].ToString();
                    col.PropertyName = CleanUp(col.Name);
                    col.PropertyType = type;
                    col.CustomType = type == null 
                        ? row["DATA_TYPE"].ToString().ToLowerInvariant() 
                        : null;
                    col.Size = GetDatatypeSize(row["DATA_TYPE"].ToString());
                    col.Precision = GetDatatypePrecision(row["DATA_TYPE"].ToString());
                    col.IsNullable = row["IS_NULLABLE"].ToString() == "YES";
                    col.IsPrimaryKey = row["COLUMN_KEY"].ToString() == "PRI";
                    col.IsAutoIncrement = row["extra"].ToString().ToLower().IndexOf("auto_increment") >= 0;

                    item.Columns.Add(col);
                }
            }

            return result;

        }

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

 public Database(string connectionString, string providerName)
 {
     _factory = DbProviderFactories.GetFactory(providerName);
     _com = _factory.CreateCommand();
     _con = _factory.CreateConnection();
     _con.ConnectionString = connectionString;
     _com.Connection = _con;
 }

 public DBHelper()
 {
     strConnectionString = ConfigurationManager.ConnectionStrings["Connectionstringname"].ConnectionString;
     objFactory = SqlClientFactory.Instance;
     objConnection = objFactory.CreateConnection();
     objCommand = objFactory.CreateCommand();
     objConnection.ConnectionString = strConnectionString;
     objCommand.Connection = objConnection;
 }

        public static DbCommand CreateCommand(DbProviderFactory dbFactory, string commandText, DbConnection connection)
        {
            if (dbFactory == null) throw new ArgumentNullException("dbFactory");

            var command = dbFactory.CreateCommand();
            command.CommandText = commandText;
            command.Connection = connection;
            return command;
        }

        ///// <summary>
        /////
        ///// </summary>
        //public SQLiteHelper()
        //    : this(s_DefaultConnectionString)
        //{
        //}
        /// <summary>
        ///
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="connectionString"></param>
        public SQLiteHelper(string connectionString)
        {
            objFactory = System.Data.SQLite.SQLiteFactory.Instance;

            objConnection = objFactory.CreateConnection();
            objCommand = new DbCommandWrapper(objFactory.CreateCommand());

            objConnection.ConnectionString = connectionString;
            objCommand.Connection = objConnection;
        }

        /// <summary>
        /// 
        /// </summary>
        public DBTransactionManager(string _connectionKey)
        {
            //Cria uma conexao na base padrão do AppSettings (Web.config)
            dbConnectionProvider = new DBConnectionProvider();
            dbConnection = dbConnectionProvider.GetConnection(_connectionKey);

            //Cria o objeto command a partir do tipo do Provider do AppSettings (Web.config)
            factory = DBConnectionProvider.GetDbFactory();
            command = factory.CreateCommand();
        }

        /// <summary>
        /// Basic DAL object to communicate with data source
        /// </summary>
        /// <param name="ConnectionString">Data source connection string</param>
        /// <param name="ProviderName">Data source provider name</param>
        public DataAccess(string ConnectionString, string ProviderName)
        {
            this.conStr = ConnectionString;
            this.prName = ProviderName;

            factory = DbProviderFactories.GetFactory(prName);
            cn = factory.CreateConnection();
            com = factory.CreateCommand();
            com.Connection = cn;
            cn.ConnectionString = conStr;
        }

 public ControladorDB(string dataNameConnectionInConfigFile)
 {
     _exception = null;
     _dataNameConnectionInConfigFile = dataNameConnectionInConfigFile;
     try
     { _dbFactory = DbProviderFactories.GetFactory(ConfigurationManager.ConnectionStrings[_dataNameConnectionInConfigFile].ProviderName); }
     catch (Exception ex)
     {
         _exception = new Exception("No fue posible obtener el proveedor de datos especificado en el archivo de configuración de la aplicación.", ex);
         return;
     }
     _command = _dbFactory.CreateCommand();
     _command.CommandType = CommandType.StoredProcedure;
     _command.Connection = _dbFactory.CreateConnection();
 }

        public override TableCollection ReadSchema(DbConnection connection, DbProviderFactory factory)
        {
            var result = new TableCollection();

            _connection = connection;
            _factory = factory;

            var cmd = _factory.CreateCommand();
            cmd.Connection = connection;
            cmd.CommandText = TABLE_SQL;

            //pull the TableCollection in a reader
            using (cmd)
            {
                using (var rdr = cmd.ExecuteReader())
                {
                    while (rdr.Read())
                    {
                        var tbl = new Table();
                        tbl.Name = rdr["TABLE_NAME"].ToString();
                        tbl.Schema = rdr["TABLE_SCHEMA"].ToString();
                        tbl.IsView =
                            String.Compare(rdr["TABLE_TYPE"].ToString(), "View", StringComparison.OrdinalIgnoreCase) ==
                            0;
                        tbl.CleanName = CleanUp(tbl.Name);
                        tbl.ClassName = Inflector.Instance.MakeSingular(tbl.CleanName);

                        result.Add(tbl);
                    }
                }
            }

            foreach (var tbl in result)
            {
                tbl.Columns = LoadColumns(tbl);

                // Mark the primary key
                var primaryKey = GetPrimaryKey(tbl.Name);
                var pkColumn = tbl.Columns.SingleOrDefault(x => x.Name.ToLower().Trim() == primaryKey.ToLower().Trim());
                if (pkColumn != null)
                {
                    pkColumn.IsPrimaryKey = true;
                }
            }


            return result;
        }

 public HospitalDAL(string dataProvider, string connectionString)
 {
     try
     {
         _dbProviderFactory = DbProviderFactories.GetFactory(dataProvider);
         _sqlConnection = _dbProviderFactory.CreateConnection();
         _command = _dbProviderFactory.CreateCommand();
         _command.Connection = _sqlConnection;
         _sqlConnection.ConnectionString = connectionString;
     }
     catch (Exception ex)
     {
         //LOGGING
         Logger.Error("Can't load data storage!",ex);
         throw new InvalidOperationException("Can't load data storage!");
     }
 }

 private void AddCommandInitStatements(IList statements, CodeExpression commandExpression, DbSourceCommand command, DbProviderFactory currentFactory, bool isFunctionsDataComponent)
 {
     if (((statements == null) || (commandExpression == null)) || (command == null))
     {
         throw new InternalException("Argument should not be null.");
     }
     Type parameterType = currentFactory.CreateParameter().GetType();
     Type type = currentFactory.CreateCommand().GetType();
     CodeExpression parameterVariable = null;
     statements.Add(CodeGenHelper.Assign(commandExpression, CodeGenHelper.New(CodeGenHelper.GlobalType(type), new CodeExpression[0])));
     if (isFunctionsDataComponent)
     {
         commandExpression = CodeGenHelper.Cast(CodeGenHelper.GlobalType(type), commandExpression);
     }
     if ((((DbSource) command.Parent).Connection == null) || ((this.designTable.Connection != null) && (this.designTable.Connection == ((DbSource) command.Parent).Connection)))
     {
         statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(commandExpression, "Connection"), CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.DefaultConnectionPropertyName)));
     }
     else
     {
         Type type3 = currentFactory.CreateConnection().GetType();
         IDesignConnection connection = ((DbSource) command.Parent).Connection;
         CodeExpression propertyReference = null;
         if (connection.PropertyReference == null)
         {
             propertyReference = CodeGenHelper.Str(connection.ConnectionStringObject.ToFullString());
         }
         else
         {
             propertyReference = connection.PropertyReference;
         }
         statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(commandExpression, "Connection"), CodeGenHelper.New(CodeGenHelper.GlobalType(type3), new CodeExpression[] { propertyReference })));
     }
     statements.Add(QueryGeneratorBase.SetCommandTextStatement(commandExpression, command.CommandText));
     statements.Add(QueryGeneratorBase.SetCommandTypeStatement(commandExpression, command.CommandType));
     if (command.Parameters != null)
     {
         foreach (DesignParameter parameter in command.Parameters)
         {
             parameterVariable = QueryGeneratorBase.AddNewParameterStatements(parameter, parameterType, currentFactory, statements, parameterVariable);
             statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(commandExpression, "Parameters"), "Add", new CodeExpression[] { parameterVariable })));
         }
     }
 }