DATASET 与 DATAREADER对象有什么区别

 datareader和dataset最大的区别在于,datareader使用时始终占用sqlconnection(俗称：非断开式连接),在线操作数据库时，任何对sqlconnection的操作都会引发datareader的异常。因为datareader每次只在内存中加载一条数据,所以占用的内存是很小的。由于datareader的特殊性和高性能，所以datareader是只进的，你读了第一条后就不能再去读取第一条了。 dataset则是将数据一次性加载在内存中，抛弃数据库连接(俗称：断开式连接)。读取完毕即放弃数据库连接，因为dataset将数据全部加载在内存中，所以比较消耗内存。但是确比datareader要灵活，可以动态的添加行,列,数据，对数据库进行回传，更新操作等。

使用datareader与dataset都可以从数据源读取数据。datareader本身是通过idbcommand.executereader()方法进行构建的；而dataset则是通过dbdataadapter.fill()方法进行填充。此外，两者的工作方式有明显的不同：datareader的执行过程不能脱离数据库连接，也就是在datareader读取数据的时候不能够使用idbconnection.close()方法关闭数据库连接；而在使用dataset获取数据时，可以断开数据库的连接，因为此时dbdataadapter已经负责将数据获取到应用服务器中了。
由于有这样的区别，所以在开发数据库相关程序时需要特别注意。例如在使用datareader获取数据后，应该主动地关闭数据库连接，否则可能出现数据库连接池溢出的异常。

datareader与dataset最根本的区别就在于一个是在线处理，另一个是离线处理。在线时，得到的是数据库当前的真实数据，但总是在线的话，增加了网络的通讯负担。离线后数据拷贝在本地，可以减轻网络负担，程序处理数据更加方便，若离线时间过长，看到的数据就不一定是真实的数据了。

下面分享下自己oracle的一个sqlhelper类，提供了两种方法获取数据，还包括存储过程等。。

/*xcy于11.09修改，原sqlserver的dbhelper*/ 
using oracle.manageddataaccess.client; 
using system; 
using system.collections.generic; 
using system.configuration; 
using system.data; 
using system.linq; 
using system.web; 
namespace jgs.utility 
{ 
public class sqlhelper 
{ 
//连接字符串 
static string strconn = configurationmanager.connectionstrings["xcycon"].tostring(); 
#region 执行查询，返回datatable对象----------------------- 
public static datatable gettable(string strsql) 
{ 
return gettable(strsql, null); 
} 
public static datatable gettable(string strsql, oracleparameter[] pas) 
{ 
return gettable(strsql, pas, commandtype.text); 
} 
/// <summary> 
/// 执行查询，返回datatable对象 
/// </summary> 
/// <param name="strsql">sql语句</param> 
/// <param name="pas">参数数组</param> 
/// <param name="cmdtype">command类型</param> 
/// <returns>datatable对象</returns> 
public static datatable gettable(string strsql, oracleparameter[] pas, commandtype cmdtype) 
{ 
datatable dt = new datatable(); ; 
using (oracleconnection conn = new oracleconnection(strconn)) 
{ 
oracledataadapter da = new oracledataadapter(strsql, conn); 
da.selectcommand.commandtype = cmdtype; 
if (pas != null) 
{ 
da.selectcommand.parameters.addrange(pas); 
} 
da.fill(dt); 
} 
return dt; 
} 
#endregion 
#region 执行查询，返回dataset对象------------------------- 
public static dataset getdataset(string strsql) 
{ 
return getdataset(strsql, null); 
} 
public static dataset getdataset(string strsql, oracleparameter[] pas) 
{ 
return getdataset(strsql, pas, commandtype.text); 
} 
/// <summary> 
/// 执行查询，返回dataset对象 
/// </summary> 
/// <param name="strsql">sql语句</param> 
/// <param name="pas">参数数组</param> 
/// <param name="cmdtype">command类型</param> 
/// <returns>dataset对象</returns> 
public static dataset getdataset(string strsql, oracleparameter[] pas, commandtype cmdtype) 
{ 
dataset dt = new dataset(); 
using (oracleconnection conn = new oracleconnection(strconn)) 
{ 
oracledataadapter da = new oracledataadapter(strsql, conn); 
da.selectcommand.commandtype = cmdtype; 
if (pas != null) 
{ 
da.selectcommand.parameters.addrange(pas); 
} 
da.fill(dt); 
} 
return dt; 
} 
#endregion 
#region 执行非查询存储过程和sql语句----------------------------- 
public static int excuteproc(string procname) 
{ 
return excutesql(procname, null, commandtype.storedprocedure); 
} 
public static int excuteproc(string procname, oracleparameter[] pars) 
{ 
return excutesql(procname, pars, commandtype.storedprocedure); 
} 
public static int excutesql(string strsql) 
{ 
return excutesql(strsql, null); 
} 
public static int excutesql(string strsql, oracleparameter[] paras) 
{ 
return excutesql(strsql, paras, commandtype.text); 
} 
/// 执行非查询存储过程和sql语句 
/// 增、删、改 
/// </summary> 
/// <param name="strsql">要执行的sql语句</param> 
/// <param name="paras">参数列表，没有参数填入null</param> 
/// <param name="cmdtype">command类型</param> 
/// <returns>返回影响行数</returns> 
public static int excutesql(string strsql, oracleparameter[] paras, commandtype cmdtype) 
{ 
int i = 0; 
using (oracleconnection conn = new oracleconnection(strconn)) 
{ 
oraclecommand cmd = new oraclecommand(strsql, conn); 
cmd.commandtype = cmdtype; 
if (paras != null) 
{ 
cmd.parameters.addrange(paras); 
} 
conn.open(); 
i = cmd.executenonquery(); 
conn.close(); 
} 
return i; 
} 
#endregion 
#region 执行查询返回第一行，第一列--------------------------------- 
public static int excutescalarsql(string strsql) 
{ 
return excutescalarsql(strsql, null); 
} 
public static int excutescalarsql(string strsql, oracleparameter[] paras) 
{ 
return excutescalarsql(strsql, paras, commandtype.text); 
} 
public static int excutescalarproc(string strsql, oracleparameter[] paras) 
{ 
return excutescalarsql(strsql, paras, commandtype.storedprocedure); 
} 
/// <summary> 
/// 执行sql语句，返回第一行，第一列 
/// </summary> 
/// <param name="strsql">要执行的sql语句</param> 
/// <param name="paras">参数列表，没有参数填入null</param> 
/// <returns>返回影响行数</returns> 
public static int excutescalarsql(string strsql, oracleparameter[] paras, commandtype cmdtype) 
{ 
int i = 0; 
using (oracleconnection conn = new oracleconnection(strconn)) 
{ 
oraclecommand cmd = new oraclecommand(strsql, conn); 
cmd.commandtype = cmdtype; 
if (paras != null) 
{ 
cmd.parameters.addrange(paras); 
} 
conn.open(); 
i = convert.toint32(cmd.executescalar()); 
conn.close(); 
} 
return i; 
} 
#endregion 
#region 查询获取单个值------------------------------------ 
/// <summary> 
/// 调用不带参数的存储过程获取单个值 
/// </summary> 
/// <param name="procname"></param> 
/// <returns></returns> 
public static object getobjectbyproc(string procname) 
{ 
return getobjectbyproc(procname, null); 
} 
/// <summary> 
/// 调用带参数的存储过程获取单个值 
/// </summary> 
/// <param name="procname"></param> 
/// <param name="paras"></param> 
/// <returns></returns> 
public static object getobjectbyproc(string procname, oracleparameter[] paras) 
{ 
return getobject(procname, paras, commandtype.storedprocedure); 
} 
/// <summary> 
/// 根据sql语句获取单个值 
/// </summary> 
/// <param name="strsql"></param> 
/// <returns></returns> 
public static object getobject(string strsql) 
{ 
return getobject(strsql, null); 
} 
/// <summary> 
/// 根据sql语句 和 参数数组获取单个值 
/// </summary> 
/// <param name="strsql"></param> 
/// <param name="paras"></param> 
/// <returns></returns> 
public static object getobject(string strsql, oracleparameter[] paras) 
{ 
return getobject(strsql, paras, commandtype.text); 
} 
/// <summary> 
/// 执行sql语句，返回首行首列 
/// </summary> 
/// <param name="strsql">要执行的sql语句</param> 
/// <param name="paras">参数列表，没有参数填入null</param> 
/// <returns>返回的首行首列</returns> 
public static object getobject(string strsql, oracleparameter[] paras, commandtype cmdtype) 
{ 
object o = null; 
using (oracleconnection conn = new oracleconnection(strconn)) 
{ 
oraclecommand cmd = new oraclecommand(strsql, conn); 
cmd.commandtype = cmdtype; 
if (paras != null) 
{ 
cmd.parameters.addrange(paras); 
} 
conn.open(); 
o = cmd.executescalar(); 
conn.close(); 
} 
return o; 
} 
#endregion 
#region 查询获取datareader------------------------------------ 
/// <summary> 
/// 调用不带参数的存储过程，返回datareader对象 
/// </summary> 
/// <param name="procname">存储过程名称</param> 
/// <returns>datareader对象</returns> 
public static oracledatareader getreaderbyproc(string procname) 
{ 
return getreaderbyproc(procname, null); 
} 
/// <summary> 
/// 调用带有参数的存储过程，返回datareader对象 
/// </summary> 
/// <param name="procname">存储过程名</param> 
/// <param name="paras">参数数组</param> 
/// <returns>datareader对象</returns> 
public static oracledatareader getreaderbyproc(string procname, oracleparameter[] paras) 
{ 
return getreader(procname, paras, commandtype.storedprocedure); 
} 
/// <summary> 
/// 根据sql语句返回datareader对象 
/// </summary> 
/// <param name="strsql">sql语句</param> 
/// <returns>datareader对象</returns> 
public static oracledatareader getreader(string strsql) 
{ 
return getreader(strsql, null); 
} 
/// <summary> 
/// 根据sql语句和参数返回datareader对象 
/// </summary> 
/// <param name="strsql">sql语句</param> 
/// <param name="paras">参数数组</param> 
/// <returns>datareader对象</returns> 
public static oracledatareader getreader(string strsql, oracleparameter[] paras) 
{ 
return getreader(strsql, paras, commandtype.text); 
} 
/// <summary> 
/// 查询sql语句获取datareader 
/// </summary> 
/// <param name="strsql">查询的sql语句</param> 
/// <param name="paras">参数列表，没有参数填入null</param> 
/// <returns>查询到的datareader（关闭该对象的时候，自动关闭连接）</returns> 
public static oracledatareader getreader(string strsql, oracleparameter[] paras, commandtype cmdtype) 
{ 
oracledatareader sqldr = null; 
oracleconnection conn = new oracleconnection(strconn); 
oraclecommand cmd = new oraclecommand(strsql, conn); 
cmd.commandtype = cmdtype; 
if (paras != null) 
{ 
cmd.parameters.addrange(paras); 
} 
conn.open(); 
//commandbehavior.closeconnection的作用是如果关联的datareader对象关闭，则连接自动关闭 
sqldr = cmd.executereader(commandbehavior.closeconnection); 
return sqldr; 
} 
#endregion 
/* 
#region 批量插入数据--------------------------------------------- 
/// <summary> 
/// 往数据库中批量插入数据 
/// </summary> 
/// <param name="sourcedt">数据源表</param> 
/// <param name="targettable">服务器上目标表</param> 
public static void bulktodb(datatable sourcedt, string targettable) 
{ 
oracleconnection conn = new oracleconnection(strconn); 
sqlbulkcopy bulkcopy = new sqlbulkcopy(conn); //用其它源的数据有效批量加载sql server表中 
bulkcopy.destinationtablename = targettable; //服务器上目标表的名称 
bulkcopy.batchsize = sourcedt.rows.count; //每一批次中的行数 
try 
{ 
conn.open(); 
if (sourcedt != null && sourcedt.rows.count != 0) 
bulkcopy.writetoserver(sourcedt); //将提供的数据源中的所有行复制到目标表中 
} 
catch (exception ex) 
{ 
throw ex; 
} 
finally 
{ 
conn.close(); 
if (bulkcopy != null) 
bulkcopy.close(); 
} 
} 
#endregion 
*/ 
} 
} 

以上所述是小编给大家介绍的dataset 与 datareader对象有什么区别，希望对大家有所帮助