分层开发问题（100分）
1.datareader 在分层开发时要怎么用
datareader的速度比dataset快，在开发中只显示数据信息不做修改，不分页时要尽量使用datareader
但在分层时怎么返回相关的数据
比如在用dataset时我们可以这样
public dataset GetData()
{
...
dataadapter.fill(ds);
return ds;
}
如果用datareader要怎么返回？？

2.在分层开发中如何用dataadapter.update(ds)做批更新
比如说有这样的例子 我要在页面里查询100条数据 查出后做修改 然后批更新到数据库

当查询时 数据访问层方法 返回dataset 显示层 显示相应信息
public dataset GetData()---数据访问层
{
...
dataadapter.fill(ds);
return ds;
}

private void BindData（dataset ds）--显示层
{
datagride1.datasource = ds;
datagride1.Bind();
}
当我修改好后要批更新数据库信息 我把这个ds传回数据访问层直接调用dataadapter.update(ds)就可以了吗 ？



[解决办法]
我的数据层借你看看.

C# code

using System;using System.Data;using System.Configuration;using System.Web;using System.Web.Security;using System.Collections;using System.Data.OracleClient;/// <summary>/// 数据库的通用访问代码/// 此类为抽象类，不允许实例化，在应用时直接调用即可/// </summary>public abstract class OracleHelper{    //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改    public static readonly string ConnectionStringLocalTransaction = ConfigurationManager.ConnectionStrings["OraConnString1"].ConnectionString;    //public static readonly string ConnectionStringInventoryDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString2"].ConnectionString;    //public static readonly string ConnectionStringOrderDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString3"].ConnectionString;    //public static readonly string ConnectionStringProfile = ConfigurationManager.ConnectionStrings["SQLProfileConnString"].ConnectionString;    // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。    private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());    /// <summary>    ///执行一个不需要返回值的OracleCommand命令，通过指定专用的连接字符串。    /// 使用参数数组形式提供参数列表     /// </summary>    /// <remarks>    /// 使用示例：    ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">一个有效的数据库连接字符串</param>    /// <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>    /// <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表</param>    /// <returns>返回一个数值表示此OracleCommand命令执行后影响的行数</returns>    public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)    {        OracleCommand cmd = new OracleCommand();        using (OracleConnection conn = new OracleConnection(connectionString))        {            //通过PrePareCommand方法将参数逐个加入到OracleCommand的参数集合中            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);            int val = cmd.ExecuteNonQuery();            //清空OracleCommand中的参数列表            cmd.Parameters.Clear();            return val;        }    }    /// <summary>    ///执行一条不返回结果的OracleCommand，通过一个已经存在的数据库连接     /// 使用参数数组提供参数    /// </summary>    /// <remarks>    /// 使用示例：      ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24));    /// </remarks>    /// <param name="conn">一个现有的数据库连接</param>    /// <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>    /// <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表</param>    /// <returns>返回一个数值表示此OracleCommand命令执行后影响的行数</returns>    public static int ExecuteNonQuery(OracleConnection connection, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)    {        OracleCommand cmd = new OracleCommand();        PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);        int val = cmd.ExecuteNonQuery();        cmd.Parameters.Clear();        connection.Close();        return val;    }    /// <summary>    /// 执行一条不返回结果的OracleCommand，通过一个已经存在的数据库事物处理     /// 使用参数数组提供参数    /// </summary>    /// <remarks>    /// 使用示例：     ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24));    /// </remarks>    /// <param name="trans">一个存在的 sql 事物处理</param>    /// <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>    /// <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表</param>    /// <returns>返回一个数值表示此OracleCommand命令执行后影响的行数</returns>    public static int ExecuteNonQuery(OracleTransaction trans, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)    {        OracleCommand cmd = new OracleCommand();        PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);        int val = cmd.ExecuteNonQuery();        cmd.Parameters.Clear();        return val;    }    /// <summary>    /// 执行一条返回结果集的OracleCommand命令，通过专用的连接字符串。    /// 使用参数数组提供参数    /// </summary>    /// <remarks>    /// 使用示例：      ///  OracleDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">一个有效的数据库连接字符串</param>    /// <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>    /// <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表</param>    /// <returns>返回一个包含结果的OracleDataReader</returns>    public static OracleDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)    {        OracleCommand cmd = new OracleCommand();        OracleConnection conn = new OracleConnection(connectionString);        // 在这里使用try/catch处理是因为如果方法出现异常，则OracleDataReader就不存在，        //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。        //关闭数据库连接，并通过throw再次引发捕捉到的异常。        try        {            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);            OracleDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);            cmd.Parameters.Clear();            return rdr;        }        catch        {            conn.Close();            throw;        }    } 
 
[解决办法]
C# code
public static OracleDataAdapter OracleAdapter(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters) 
   { 
     OracleCommand cmd = new OracleCommand(); 
     OracleConnection conn = new OracleConnection(connectionString); 
  
     // 在这里使用try/catch处理是因为如果方法出现异常，则OracleDataReader就不存在， 
     //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。 
     //关闭数据库连接，并通过throw再次引发捕捉到的异常。 
     try 
     { 
       PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters); 
       OracleDataAdapter oda = new OracleDataAdapter(cmd); 
       //oda.Fill(ds); 
       cmd.Parameters.Clear(); 
       conn.Close(); 
       return oda; 
     } 
     catch 
     { 
       conn.Close(); 
       throw; 
     } 
   } 
  
   ///  <summary> 
   /// 执行一条返回第一条记录第一列的OracleCommand命令，通过专用的连接字符串。  
   /// 使用参数数组提供参数 
   ///  </summary> 
   ///  <remarks> 
   /// 使用示例：   
   ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24)); 
   ///  </remarks> 
   ///  <param name="connectionString">一个有效的数据库连接字符串 </param> 
   ///  <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
   ///  <param name="commandText">存储过程的名字或者 T-SQL 语句 </param> 
   ///  <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表 </param> 
   ///  <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型 </returns> 
   public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters) 
   { 
     OracleCommand cmd = new OracleCommand(); 
  
     using (OracleConnection connection = new OracleConnection(connectionString)) 
     { 
       PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters); 
       object val = cmd.ExecuteScalar(); 
       cmd.Parameters.Clear(); 
       return val; 
     } 
   } 
  
   ///  <summary> 
   /// 执行一条返回第一条记录第一列的OracleCommand命令，通过已经存在的数据库连接。 
   /// 使用参数数组提供参数 
   ///  </summary> 
   ///  <remarks> 
   /// 使用示例：  
   ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24)); 
   ///  </remarks> 
   ///  <param name="conn">一个已经存在的数据库连接 </param> 
   ///  <param name="commandType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
   ///  <param name="commandText">存储过程的名字或者 T-SQL 语句 </param> 
   ///  <param name="commandParameters">以数组形式提供OracleCommand命令中用到的参数列表 </param> 
   ///  <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型 </returns> 
   public static object ExecuteScalar(OracleConnection connection, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters) 
   { 
  
     OracleCommand cmd = new OracleCommand(); 
  
     PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
 
     object val = cmd.ExecuteScalar(); 
     cmd.Parameters.Clear(); 
     return val; 
   } 
  
   ///  <summary> 
   /// 缓存参数数组 
   ///  </summary> 
   ///  <param name="cacheKey">参数缓存的键值 </param> 
   ///  <param name="cmdParms">被缓存的参数列表 </param> 
   public static void CacheParameters(string cacheKey, params OracleParameter[] commandParameters) 
   { 
     parmCache[cacheKey] = commandParameters; 
   } 
  
   ///  <summary> 
   /// 获取被缓存的参数 
   ///  </summary> 
   ///  <param name="cacheKey">用于查找参数的KEY值 </param> 
   ///  <returns>返回缓存的参数数组 </returns> 
   public static OracleParameter[] GetCachedParameters(string cacheKey) 
   { 
     OracleParameter[] cachedParms = (OracleParameter[])parmCache[cacheKey]; 
  
     if (cachedParms == null) 
       return null; 
  
     //新建一个参数的克隆列表 
     OracleParameter[] clonedParms = new OracleParameter[cachedParms.Length]; 
  
     //通过循环为克隆参数列表赋值 
     for (int i = 0, j = cachedParms.Length; i  < j; i++) 
       //使用clone方法复制参数列表中的参数 
       clonedParms[i] = (OracleParameter)((ICloneable)cachedParms[i]).Clone(); 
  
     return clonedParms; 
   } 
  
   ///  <summary> 
   /// 为执行命令准备参数 
   ///  </summary> 
   ///  <param name="cmd">OracleCommand 命令 </param> 
   ///  <param name="conn">已经存在的数据库连接 </param> 
   ///  <param name="trans">数据库事物处理 </param> 
   ///  <param name="cmdType">OracleCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
   ///  <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products </param> 
   ///  <param name="cmdParms">返回带参数的命令 </param> 
   private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trans, CommandType cmdType, string cmdText, OracleParameter[] cmdParms) 
   { 
  
     //判断数据库连接状态 
     if (conn.State != ConnectionState.Open) 
       conn.Open(); 
  
     cmd.Connection = conn; 
     cmd.CommandText = cmdText; 
  
     //判断是否需要事物处理 
     if (trans != null) 
       cmd.Transaction = trans; 
  
     cmd.CommandType = cmdType; 
  
     if (cmdParms != null) 
     { 
       foreach (OracleParameter parm in cmdParms) 
         cmd.Parameters.Add(parm); 
     } 
   } 
 }

[解决办法]
个人见解：
1、分层已经是降低效率了，那么一定要用DataReader吗？
2、调用dataadapter.update前，要设置CommandBuilder
[解决办法]
1 System.Data.SqlClient.SqlDataReader 直接返回SqlDataReader ，或者 object，或者范型
2 dataadapter.update(ds)就可以了，值得注意的是，ds里的数据状态DataRowState 是否已经修改过来 。 这种情况不适合大数据量的操作。