C# DbCommand.ExecuteReader方法代码示例

 public IDataReader ExecuteReader(DbCommand cmd)
 {
     DbConnection conn = null;
     try {
         conn = this.GetOpenConnection();
         cmd.Connection = conn;
         CommandBehavior behavior = this.IsSharedConnection() ? CommandBehavior.Default : CommandBehavior.CloseConnection;
         return cmd.ExecuteReader(behavior);
     } catch {
         ReleaseConnection(conn);
         throw;
     }
 }

 //----------------------------------------------------------------------------------------------------
 /// <summary>
 /// 쿼리 요청 ( SELECT )
 /// </summary>
 /// <param name="sql">SQL문</param>
 /// <returns>성공 유무</returns>
 //----------------------------------------------------------------------------------------------------
 public bool Query( string sql )
 {
     try
     {
         CloseQuery();
         m_command = m_connection.CreateCommand();
         m_command.CommandText = sql;
         m_reader = m_command.ExecuteReader();
         return true;
     }
     catch( Exception ex )
     {
         Log( ex.ToString() );
         m_error = ex.Message;
         CloseQuery();
         return false;
     }
 }

        /// <summary>
        /// Create a DataReader for the specified command.  
        /// <para>Please note that the associated connection is automatically closed when then datareader is closed.</para>
        /// </summary>
        public DbDataReader CreateDataReader(DbCommand cm)
        {
            DbConnection cn = cm.Connection;
            DbDataReader rd = null;

            errorMessage = "";
            try
            {
                if (cn.State != ConnectionState.Open)
                    cn.Open();
                rd = cm.ExecuteReader(CommandBehavior.CloseConnection);
                return rd;
            }
            catch (Exception ex)
            {
                errorMessage = ex.Message;
                if (logEvents)
                    LogEvent("ERROR", cm.CommandText + "\r\n/\r\n" + ex.ToString());
                if (cn.State == ConnectionState.Open)
                    cn.Close();
                return null;
            }
        }

        /// <summary>
        /// Executes a command, and returns 1 row at a time until all rows are returned
        /// </summary>
        /// <param name="Command">The database command to execute the reader on</param>
        /// <returns></returns>
        public IEnumerable<Dictionary<string, object>> QueryReader(DbCommand Command)
        {
            // Increase Query Count
            NumQueries++;

            // Execute the query
            using (Command)
            using (DbDataReader Reader = Command.ExecuteReader())
            {
                // If we have rows, add them to the list
                if (Reader.HasRows)
                {
                    // Add each row to the rows list
                    while (Reader.Read())
                    {
                        Dictionary<string, object> Row = new Dictionary<string, object>(Reader.FieldCount);
                        for (int i = 0; i < Reader.FieldCount; ++i)
                            Row.Add(Reader.GetName(i), Reader.GetValue(i));

                        yield return Row;
                    }
                }

                // Cleanup
                Reader.Close();
            }
        }

        /// <summary>
        /// Executes a command, and returns the resulting rows
        /// </summary>
        /// <param name="Command">The database command to execute the reader on</param>
        /// <returns></returns>
        public List<Dictionary<string, object>> ExecuteReader(DbCommand Command)
        {
            // Execute the query
            List<Dictionary<string, object>> Rows = new List<Dictionary<string, object>>();
            DbDataReader Reader = Command.ExecuteReader();

            // If we have rows, add them to the list
            if (Reader.HasRows)
            {
                // Add each row to the rows list
                while (Reader.Read())
                {
                    Dictionary<string, object> Row = new Dictionary<string, object>(Reader.FieldCount);
                    for (int i = 0; i < Reader.FieldCount; ++i)
                        Row.Add(Reader.GetName(i), Reader.GetValue(i));

                    Rows.Add(Row);
                }
            }

            // Cleanup
            Reader.Close();
            Reader.Dispose();
            Command.Dispose();

            // Return Rows
            return Rows;
        }

 public IDataReader ExecuteReader(DbCommand command)
 {
     DbConnection conn = GetOpenConnection();
     command.Connection = conn;
     CommandBehavior commandBehavior = IsSharedConnection() ? CommandBehavior.Default : CommandBehavior.CloseConnection;
     return command.ExecuteReader(commandBehavior);
 }

        /// <summary>
        /// Dumps the result of a given SQL query into a tab separated file.
        /// </summary>
        /// <param name="command">The database to pull the data from.</param>
        /// <param name="query">The query to select the data with.</param>
        /// <param name="filename">The file to dump the results to.</param>
        private void DumpRecordsFromTable(DbCommand command, string query, string filename)
        {
            command.CommandText = query;
            using (StreamWriter writer = new StreamWriter($"migrate\\{filename}"))
            using (DbDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    for (int i = 0; i < reader.FieldCount; ++i)
                    {
                        if (i != 0)
                        {
                            writer.Write('\t');
                        }

                        object val = reader.GetValue(i);
                        writer.Write(val);
                    }

                    writer.WriteLine();
                }
            }
        }

 //metodo para retornar o leitor usado para ler os Selects usados
 public static DbDataReader GetDataReader(DbCommand comando)
 {
     return comando.ExecuteReader();
 }

        //Select statement
        public IDataReader Select(DbCommand select_query)
        {
            try
            {
                //Open connection
                if (this.OpenConnection() != null)
                {

                    //Create a data reader and Execute the command
                    IDataReader data_reader = select_query.ExecuteReader();

                    //return data reader so programmer can read results
                    return data_reader;
                }

            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
               return null;
        }

 public DataTable ReadTable(DbCommand cmd)
 {
     DataTable dt = new DataTable();
     DbDataReader reader = null;
     try
     {
         reader = cmd.ExecuteReader();
         int fieldc = reader.FieldCount;
         for (int i = 0; i < fieldc; i++)
         {
             DataColumn dc = new DataColumn(reader.GetName(i), reader.GetFieldType(i));
             dt.Columns.Add(dc);
         }
         while (reader.Read())
         {
             DataRow dr = dt.NewRow();
             for (int i = 0; i < fieldc; i++)
             {
                 dr[i] = reader[i];
             }
             dt.Rows.Add(dr);
         }
         return dt;
     }
     finally
     {
         if (reader != null) reader.Close();
     }
 }

 private DataTable callStoredProcedure(string name, List<DbParameter> parameters)
 {
     DataTable results ;
     command = connection.CreateCommand();
     command.CommandText = name;
     command.CommandType = CommandType.StoredProcedure;
     command.Parameters.AddRange(parameters.ToArray());
     command.Connection = connection;
     if (connection.State != ConnectionState.Open) { connection.Open(); }
     results = new DataTable();
     results.Load(command.ExecuteReader());
     return results;
 }