【转】.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
内存	Kingston DDR2 667 1G
硬盘	80G 5400转 8m

软件：

操作系统	Windows Server 2003
数据库系统	SQL Server 2005 Enterprise
数据规模	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的代码:

 

Code
 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的代码:

 

Code
 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方法的源码，我们使用反射器查看，代码如下：

protected   virtual   int  Fill(DataSet dataSet,  string  srcTable, IDataReader dataReader,  int  startRecord,  int  maxRecords)
{
     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方法代码如下：

internal   bool  Run(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj)
{
     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应该都是数据容器。做个类比的话，应该是茶壶和茶杯的关系。至于查询数据，除了取决于容器，还和具体负责查询和装载数据的类有关系。 我文章的标题，应该说是有问题的，这种比较忽略了一个数据查询和装载的过程。有不合理的地方。现在更正。

转载于:https://www.cnblogs.com/jiangj/archive/2010/08/20/1804500.html