【转】.NET深入学习笔记(1)：DataSet和SqlDataReader性能差异深入剖析与测试
声明：这篇文章可能存在错误，我对于 DataSet和SqlDataReader概念的理解有误，当时主要是针对网络上一个面试的题目做出的，测试。我在核实资料后与验证代码后会做出更新。
我已经使用Reflector查看了SQLDataAdapter类型的Fill方法以及SqlCommand.ExecuteReader 方法代码。确实有使用DataReader的地方。他们是真正负责处理查询并装在数据。DataReader和DataSet应该都是数据容器。做个类比的话，应该是茶壶和茶杯的关系。 至于查询数据，除了取决于容器，还和具体负责查询和装载数据的类有关系。 我文章的标题，应该说是有问题的，这种比较忽略了一个数据查询和装载的过程。有不合理的地方。现在更正。
2009年已经来临,中国的新春佳节就要到来.首先祝各位新年快乐,牛年大吉~~此篇文章作为我blog的第一篇文章,写出来希望能与大家一起分享经验,交流技术.
DataSet和SqlDataReader的比较的文章和帖子网上已经很多,我也看了很多前辈的随笔.自己在面试和实际工作中也遇到这样的问题.但是始终是没深入进行学习.最近在工作空闲之余,特地查阅了一些文章,也包括msdn的官方文档.自己建立数据库和测试程序,对DataSet和SqlDataReader做了比较.
首先关于两者比较主流的观点就是:
1.DataReader使用时始终占用SqlConnection,在线操作数据库.DataSet则是将数据一次性加载在内存中.支持数据库访问的断开连接模型.
2.DataReader每次只在内存中加载一条数据,节约内存.DataSet将数据全部加载在内存中.比较消耗内存.
3.DataReader单向只读.DataSet支持查询\修改\删除等操作,比较灵活.
4.DataReader与 SqlCommand搭配.DataSet与DataAdapter 结合使用.
为什么会这样呢?我们就来分析一下具体的原因.查看一下msdn关于 两者的不同描述:
1>SqlDataReader 类提供一种从 SQL Server 数据库读取行的只进流的方式。无法继承此类。 命名空间： System.Data.SqlClient程序集： System.Data（在 System.Data.dll 中）.可以使用 ADO.NET DataReader 从数据库中检索只读、只进的数据流。查询结果在查询执行时返回，在并存储在客户端的网络缓冲区中，直到您使用 DataReader 的 Read 方法对它们发出请求。使用 DataReader 可以提高应用程序的性能，原因是它只要数据可用就立即检索数据，并且（默认情况下）一次只在内存中存储一行，减少了系统开销。
2>DataSet 对象是支持 ADO.NET 的断开式、分布式数据方案的核心对象。DataSet 是数据的内存驻留表示形式，无论数据源是什么，它都会提供一致的关系编程模型。它可以用于多种不同的数据源，用于 XML 数据，或用于管理应用程序本地的数据。DataSet 表示包括相关表、约束和表间关系在内的整个数据集。下图将显示 DataSet 对象模型。
从上面的描述可以看出,DataReader和DataSet具有不同的结构模型.在数据的方式处理上也存在显著的差别.SqlDataReader 会避免创建不必要的对象或复制不必要的数据.DataSet 可以表示完整的数据模型，包括表格、约束条件和表关系.在对象的创建和销毁等环节需要消耗更多的资源,因此在性能上也稍显逊色.因此很多文章得出的结论也是在只进行读数据操作的情况下,DataReader的性能要强于DataSet.但是很多文章都没有相应的测试,就盲目下结论.
但是好奇心理的驱使使我很想来做个试验来验证一下这个结论,到底DataReader比DataSet在查询数据的时候,性能会不会胜出,如果前者更优的话那么会超出多少?我自己写了个小程序,自己建立的数据库进行了实验. 实验测试环境如下：
硬件：
|
CPU |
Intel T2300 1.66GHz |
|
内存 |
|
|
硬盘 |
|
软件：
|
操作系统 |
Windows Server 2003 |
|
数据库系统 |
SQL Server 2005 |
|
数据规模 |
1000000条数据 |
数据库表结构
Test
|
名称 |
类型 |
备注 |
|
id |
int |
标志\聚集索引 |
|
name |
nvarchar(50) |
非聚集索引 |
|
birthday |
datetime |
生日 |
|
height |
int |
身高 |
|
sex |
int |
性别 |
|
address |
nvarchar(100) |
地址 |
|
lastlogintime |
datetime |
非聚集索引 |
具体的实验程序c#代码如下,使用了using System.Data.SqlClient;
using System.Diagnostics;两个namespace下的类,Stopwatch对象用来进行计时.
测试DataSet的代码:
1
using (SqlConnection conn = new SqlConnection("Data Source=127.0.0.1;Initial Catalog=Test;Integrated Security=True"))2
{
3
Stopwatch st = new Stopwatch();4
st.Start();5
conn.Open();6
SqlDataAdapter da = new SqlDataAdapter(sQuery, conn);7
st.Stop();8
//textBox3.Text = st.ElapsedMilliseconds.ToString();9
10
st.Start();11
DataSet ds = new DataSet("test");12
da.Fill(ds);13
st.Stop();14
long ltimes = st.ElapsedMilliseconds;15
//textBox1.Text = ltimes.ToString();16
conn.Close();17
///textBox3.Text = sizeof(DataSet);
18
}19
测试DataReader的代码:
1
using (SqlConnection conn = new SqlConnection("Data Source=127.0.0.1;Initial Catalog=Test;Integrated Security=True"))2
{3
4
Stopwatch st = new Stopwatch();5
st.Start();6
conn.Open();7
SqlCommand Comm = new SqlCommand(sQuery, conn);8
st.Stop();9
textBox4.Text = st.ElapsedMilliseconds.ToString();10
st.Start();11
SqlDataReader reader = Comm.ExecuteReader();12
while (reader.Read())13
{14
15
}16
st.Stop();17
long ltimes = st.ElapsedMilliseconds;18
textBox2.Text = ltimes.ToString();19
conn.Close();20
//textBox4.Text = sizeof(SqlDataReader);21
}测试语句和时间ms分别如下:
|
语句 |
DataReader费时 |
DataSet费时 |
|
string sQuery = "SELECT * FROM dbo.test where id <= 1" |
0ms |
0ms |
|
string sQuery = "SELECT * FROM dbo.test where id <=10" |
1ms |
1ms |
|
string sQuery = "SELECT * FROM dbo.test where id <=100" |
2ms |
3ms |
|
string sQuery = "SELECT * FROM dbo.test where id <=1000" |
5ms |
6ms |
|
string sQuery = "SELECT * FROM dbo.test where id <=10000" |
8ms |
50ms |
从试验结果分析可以得出如下结论:
1.在查询数据量很少的情况下100条内,DataReader和DataSet几乎没有什么明显的性能差别.
2.数据量过大,接近10000条的时候的数据查询,DataReader的性能要明显优于DataSet.
对于两者的性能对比,不应该轻易下结论,除了参考实验设备,也要考虑实际的数据规模.
具体项目应用中,选择适合具体需求的对象进行数据处理,才能有效的提高系统的性能.
本文的测试环境和结果可能存在偏差,但是希望能给大家带来一些帮助,一起交流学习.谢谢.
【2】补充：
DataAdapter的Fill方法的源码，我们使用反射器查看，代码如下：
{
int num;
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<comm.DataAdapter.Fill|API> %d#, dataSet, srcTable, dataReader, startRecord, maxRecords\n", this.ObjectID);
try
{
if (dataSet == null)
{
throw ADP.FillRequires("dataSet");
}
if (ADP.IsEmpty(srcTable))
{
throw ADP.FillRequiresSourceTableName("srcTable");
}
if (dataReader == null)
{
throw ADP.FillRequires("dataReader");
}
if (startRecord < 0)
{
throw ADP.InvalidStartRecord("startRecord", startRecord);
}
if (maxRecords < 0)
{
throw ADP.InvalidMaxRecords("maxRecords", maxRecords);
}
if (dataReader.IsClosed)
{
return 0;
}
DataReaderContainer container = DataReaderContainer.Create(dataReader, this.ReturnProviderSpecificTypes);
num = this.FillFromReader(dataSet, null, srcTable, container, startRecord, maxRecords, null, null);
}
finally
{
Bid.ScopeLeave(ref ptr);
}
return num;
}
另外一个SqlCommand 的ExecuteReader方法最终调用Run方法代码如下：
{
if ((TdsParserState.Broken == this.State) || (this.State == TdsParserState.Closed))
{
return true;
}
bool flag = false;
Label_0016:
if (stateObj._internalTimeout)
{
runBehavior = RunBehavior.Attention;
}
if ((TdsParserState.Broken == this.State) || (this.State == TdsParserState.Closed))
{
goto Label_06DF;
}
byte token = stateObj.ReadByte();
if ((((((token != 170) && (token != 0xab)) && ((token != 0xad) && (token != 0xe3))) && (((token != 0xac) && (token != 0x79)) && ((token != 160) && (token != 0xa1)))) && ((((token != 0x81) && (token != 0x88)) && ((token != 0xa4) && (token != 0xa5))) && (((token != 0xa9) && (token != 0xd3)) && ((token != 0xd1) && (token != 0xfd))))) && ((((token != 0xfe) && (token != 0xff)) && ((token != 0x39) && (token != 0xed))) && (((token != 0xae) && (token != 0x7c)) && ((token != 120) && (token != 0xed)))))
{
this._state = TdsParserState.Broken;
this._connHandler.BreakConnection();
throw SQL.ParsingError();
}
int tokenLength = this.GetTokenLength(token, stateObj);
switch (token)
{
case 0xa4:
if (dataStream == null)
{
this.SkipBytes(tokenLength, stateObj);
}
else
{
dataStream.TableNames = this.ProcessTableName(tokenLength, stateObj);
}
goto Label_06AF;
case 0xa5:
if (dataStream == null)
{
this.SkipBytes(tokenLength, stateObj);
}
else
{
_SqlMetaDataSet metaData = this.ProcessColInfo(dataStream.MetaData, dataStream, stateObj);
dataStream.SetMetaData(metaData, false);
dataStream.BrowseModeInfoConsumed = true;
}
goto Label_06AF;
case 0xa9:
this.SkipBytes(tokenLength, stateObj);
goto Label_06AF;
case 170:
case 0xab:
{
if (token == 170)
{
stateObj._errorTokenReceived = true;
}
SqlError error = this.ProcessError(token, stateObj);
if (RunBehavior.Clean == (RunBehavior.Clean & runBehavior))
{
if (error.Class >= 20)
{
this.Errors.Add(error);
}
}
else if (((this._connHandler != null) && (this._connHandler.Connection != null)) && (this._connHandler.Connection.FireInfoMessageEventOnUserErrors && (error.Class <= 0x10)))
{
this.FireInfoMessageEvent(stateObj, error);
}
else if (error.Class < 11)
{
this.Warnings.Add(error);
}
else if (error.Class <= 0x10)
{
this.Errors.Add(error);
if ((dataStream != null) && !dataStream.IsInitialized)
{
runBehavior = RunBehavior.UntilDone;
}
}
else
{
this.Errors.Add(error);
runBehavior = RunBehavior.UntilDone;
}
goto Label_06AF;
}
case 0xac:
{
SqlReturnValue rec = this.ProcessReturnValue(tokenLength, stateObj);
if (cmdHandler != null)
{
cmdHandler.OnReturnValue(rec);
}
goto Label_06AF;
}
case 0xad:
{
SqlLoginAck ack = this.ProcessLoginAck(stateObj);
this._connHandler.OnLoginAck(ack);
goto Label_06AF;
}
case 0x88:
{
if (stateObj._cleanupAltMetaDataSetArray == null)
{
stateObj._cleanupAltMetaDataSetArray = new _SqlMetaDataSetCollection();
}
_SqlMetaDataSet altMetaDataSet = this.ProcessAltMetaData(tokenLength, stateObj);
stateObj._cleanupAltMetaDataSetArray.Add(altMetaDataSet);
if (dataStream != null)
{
dataStream.SetAltMetaDataSet(altMetaDataSet, 0x88 != stateObj.PeekByte());
}
goto Label_06AF;
}
case 0x79:
{
int status = stateObj.ReadInt32();
if (cmdHandler != null)
{
cmdHandler.OnReturnStatus(status);
}
goto Label_06AF;
}
case 0x81:
if (tokenLength != 0xffff)
{
stateObj._cleanupMetaData = this.ProcessMetaData(tokenLength, stateObj);
}
else if (cmdHandler != null)
{
stateObj._cleanupMetaData = cmdHandler.MetaData;
}
if (dataStream != null)
{
byte num5 = stateObj.PeekByte();
dataStream.SetMetaData(stateObj._cleanupMetaData, (0xa4 == num5) || (0xa5 == num5));
}
else if (bulkCopyHandler != null)
{
bulkCopyHandler.SetMetaData(stateObj._cleanupMetaData);
}
goto Label_06AF;
case 0xd1:
if (bulkCopyHandler == null)
{
if (RunBehavior.ReturnImmediately != (RunBehavior.ReturnImmediately & runBehavior))
{
this.SkipRow(stateObj._cleanupMetaData, stateObj);
}
break;
}
this.ProcessRow(stateObj._cleanupMetaData, bulkCopyHandler.CreateRowBuffer(), bulkCopyHandler.CreateIndexMap(), stateObj);
break;
case 0xd3:
if (RunBehavior.ReturnImmediately != (RunBehavior.ReturnImmediately & runBehavior))
{
int num8 = stateObj.ReadUInt16();
this.SkipRow(stateObj._cleanupAltMetaDataSetArray[num8], stateObj);
}
flag = true;
goto Label_06AF;
case 0xe3:
{
SqlEnvChange[] changeArray = this.ProcessEnvChange(tokenLength, stateObj);
for (int i = 0; i < changeArray.Length; i++)
{
if (changeArray[i] == null)
{
continue;
}
switch (changeArray[i].type)
{
case 8:
case 11:
this._currentTransaction = this._pendingTransaction;
this._pendingTransaction = null;
if (this._currentTransaction == null)
{
break;
}
this._currentTransaction.TransactionId = changeArray[i].newLongValue;
goto Label_048E;
case 9:
case 12:
case 0x11:
this._retainedTransactionId = 0L;
goto Label_04D1;
case 10:
goto Label_04D1;
default:
goto Label_0551;
}
TransactionType type = (8 == changeArray[i].type) ? TransactionType.LocalFromTSQL : TransactionType.Distributed;
this._currentTransaction = new SqlInternalTransaction(this._connHandler, type, null, changeArray[i].newLongValue);
Label_048E:
if ((this._statistics != null) && !this._statisticsIsInTransaction)
{
this._statistics.SafeIncrement(ref this._statistics._transactions);
}
this._statisticsIsInTransaction = true;
this._retainedTransactionId = 0L;
continue;
Label_04D1:
if (this._currentTransaction != null)
{
if (9 == changeArray[i].type)
{
this._currentTransaction.Completed(TransactionState.Committed);
}
else if (10 == changeArray[i].type)
{
if (this._currentTransaction.IsDistributed && this._currentTransaction.IsActive)
{
this._retainedTransactionId = changeArray[i].oldLongValue;
}
this._currentTransaction.Completed(TransactionState.Aborted);
}
else
{
this._currentTransaction.Completed(TransactionState.Unknown);
}
this._currentTransaction = null;
}
this._statisticsIsInTransaction = false;
continue;
Label_0551:
this._connHandler.OnEnvChange(changeArray[i]);
}
goto Label_06AF;
}
case 0xfd:
case 0xfe:
case 0xff:
this.ProcessDone(cmdHandler, dataStream, ref runBehavior, stateObj);
if ((token == 0xfe) && (cmdHandler != null))
{
cmdHandler.OnDoneProc();
}
goto Label_06AF;
case 0xed:
this.ProcessSSPI(tokenLength);
goto Label_06AF;
default:
goto Label_06AF;
}
if (this._statistics != null)
{
this._statistics.WaitForDoneAfterRow = true;
}
flag = true;
Label_06AF:
if ((stateObj._pendingData && (RunBehavior.ReturnImmediately != (RunBehavior.ReturnImmediately & runBehavior))) || ((!stateObj._pendingData && stateObj._attentionSent) && !stateObj._attentionReceived))
{
goto Label_0016;
}
Label_06DF:
if (!stateObj._pendingData && (this.CurrentTransaction != null))
{
this.CurrentTransaction.Activate();
}
if (stateObj._attentionSent && stateObj._attentionReceived)
{
stateObj._attentionSent = false;
stateObj._attentionReceived = false;
if ((RunBehavior.Clean != (RunBehavior.Clean & runBehavior)) && !stateObj._internalTimeout)
{
this.Errors.Add(new SqlError(0, 0, 11, this._server, SQLMessage.OperationCancelled(), "", 0));
}
}
if ((this._errors != null) || (this._warnings != null))
{
this.ThrowExceptionAndWarning(stateObj);
}
return flag;
}
我已经使用Reflector查看了SQLDataAdapter类型的Fill方法以及SqlCommand.ExecuteReader 方法代码。确实有使用DataReader的地方。他们是真正负责处理查询并装在数据。DataReader和DataSet应该都是数据容器。做个类比的话，应该是茶壶和茶杯的关系。至于查询数据，除了取决于容器，还和具体负责查询和装载数据的类有关系。 我文章的标题，应该说是有问题的，这种比较忽略了一个数据查询和装载的过程。有不合理的地方。现在更正。
