从IDataReader中读取数据实体

从IDataReader中读取数据实体

    现在ORM已经是一门非常成熟的技术了，相信用的人不少，加上Linq to sql和Entity Framework的推波助澜，现在还用DataSet和DataTable的人已经越来越少了，不过，如果项目里面不用ORM工具，就不得不回归到DataSet时代吗？

    也许，我们没法改变项目的决策，但是，我们可以自己制造工具。

    这里先忽略掉那些麻烦的sql，调用那个存储过程之类的事情，假设我们已经通过各种手段（不管你是SqlHelper的拥护者还是enterprise library的支持者，或者是自己动手丰衣足食的DIY派），得到了一个IDataReader实例（什么，你不知道IDataReader接口？去msdn看看吧），并且把msdn上的说明：

    提供一种方法来读取一个或多个通过在数据源执行命令所获得的只进结果集流

    简化成：

    提供一种方法来读取一个通过在数据源执行命令所获得的只进结果集流

    也就是说，忽略掉一个存储过程返回多个结果集的情况下，我们可以直接把这个IDataReader实例中承载的数据转换为一个List<T>的形式。

    读到这里你可能会觉得这样的功能用一个反射就可以搞定了，何必写这么一篇水文？

    不过，这里用的不是常规反射。什么意思？反射还有常规和非常规之分吗？

    常规的反射是直接使用GetProperty和SetValue就可以实现这样的功能了，但是常规反射的问题是反射的效率问题，这样的代码效率是手写代码的1/1000，也就是说，虽然你写的很轻松，但是对CLR来说，这个代码执行的非常累。

    我这里要用的是反射中的Emit技术，动态拼装IL，获得一个高性能转换器，其执行效率至少是手写代码1/2，也就是说，使用这个代码的目的是你写的轻松，CLR执行的也轻松。

    不过，在这个之前，需要先定义数据实体，这个又是每个人的习惯都不一样的东西，我个人是习惯于利用Attribute来表明哪个属性是哪一列，不过考虑到便捷性，会用一个类级的Attribute表明这个类默认为是数据列，或者表明不是默认为是数据列：

 1      [AttributeUsage(AttributeTargets.Class, Inherited  =   true , AllowMultiple  =   false )]
 2       internal   sealed   class  DbResultAttribute : Attribute
 3      {
 4 
 5           public  DbResultAttribute()
 6              :  this ( true ) { }
 7 
 8           public  DbResultAttribute( bool  defaultAsDbColumn)
 9          {
10              DefaultAsDbColumn  =  defaultAsDbColumn;
11          }
12 
13           public   bool  DefaultAsDbColumn {  get ;  private   set ; }
14 
15      }
16 

    而对于普通的属性，再给与一次修改列名和排除在数据列之外的机会：

 1      [AttributeUsage(AttributeTargets.Property, Inherited  =   true , AllowMultiple  =   false )]
 2       internal   sealed   class  DbColumnAttribute : Attribute
 3      {
 4 
 5           public  DbColumnAttribute() { }
 6 
 7           public   string  ColumnName {  get ;  set ; }
 8 
 9           public   bool  Ignore {  get ;  set ; }
10 
11      }
12 

    这样，我们就可以很简单的定义一个数据实体了：

 1      [DbResult]
 2       public   class  MyClass
 3      {
 4           public   int  IntValue {  get ;  set ; }
 5           public   string  StringValue {  get ;  set ; }
 6          [DbColumn(ColumnName  =   " DecimalValue " )]
 7           public   decimal ?  NullableDecimalAndDifferentName {  get ;  set ; }
 8           public  MyEnum EnumIsAlsoSupportted {  get ;  set ; }
 9           public  MyEnum ?  NullableEnumIsAlsoSupportted {  get ;  set ; }
10          [DbColumn(Ignore  =   true )]
11           public   object  NonDbValue {  get ;  set ; }
12      }
13 
14       public   enum  MyEnum
15      {
16          X,
17          Y,
18          Z,
19      }
20 

    定义简单吧，不过，可以看出来实现部分也是异常的复杂，除了标准的int,string,decimal类型，还要支持可空类型，以及枚举类型，甚至是可空枚举类型。。。不过，如果数据库类型和定义的类型（枚举看它的基础类型）不匹配就会直接抛出异常，这点要注意一下。

    千里之行始于足下，先做最简单的，搭建一个简单的环境，并且读取这个实体类的信息吧：

 1       public   static   class  DataReaderExtensions
 2      {
 3 
 4           #region  Public Static Methods
 5 
 6           public   static  List < T >  Select < T > ( this  IDataReader reader)
 7               where  T :  class ,  new ()
 8          {
 9               if  (reader  ==   null )
10                   throw   new  ArgumentNullException( " reader " );
11               return  EntityConverter < T > .Select(reader);
12          }
13 
14           #endregion
15 
16           #region  Class: EntityConverter<T>
17 
18           private   class  EntityConverter < T >
19               where  T :  class ,  new ()
20          {
21 
22               #region  Struct: DbColumnInfo
23 
24               private   struct  DbColumnInfo
25              {
26                   public   readonly   string  PropertyName;
27                   public   readonly   string  ColumnName;
28                   public   readonly  Type Type;
29                   public   readonly  MethodInfo SetMethod;
30 
31                   public  DbColumnInfo(PropertyInfo prop, DbColumnAttribute attr)
32                  {
33                      PropertyName  =  prop.Name;
34                      ColumnName  =  attr.ColumnName  ??  prop.Name;
35                      Type  =  prop.PropertyType;
36                      SetMethod  =  prop.GetSetMethod( false );
37                  }
38              }
39 
40               #endregion
41 
42               #region  Fields
43               private   static  Converter < IDataReader, List < T >>  batchDataLoader;
44               #endregion
45 
46               #region  Properties
47 
48               private   static  Converter < IDataReader, List < T >>  BatchDataLoader
49              {
50                   get
51                  {
52                       if  (batchDataLoader  ==   null )
53                          batchDataLoader  =  CreateBatchDataLoader( new  List < DbColumnInfo > (GetProperties()));
54                       return  batchDataLoader;
55                  }
56              }
57 
58               #endregion
59 
60               #region  Init Methods
61 
62               private   static  IEnumerable < DbColumnInfo >  GetProperties()
63              {
64                  DbResultAttribute dbResult  =  Attribute.GetCustomAttribute( typeof (T),  typeof (DbResultAttribute),  true )  as  DbResultAttribute;
65                   foreach  (var prop  in   typeof (T).GetProperties(BindingFlags.Instance  |  BindingFlags.Public))
66                  {
67                       if  (prop.GetIndexParameters().Length  >   0 )
68                           continue ;
69                      var setMethod  =  prop.GetSetMethod( false );
70                       if  (setMethod  ==   null )
71                           continue ;
72                      var attr  =  Attribute.GetCustomAttribute(prop,  typeof (DbColumnAttribute),  true )  as  DbColumnAttribute;
73                       if  (dbResult  !=   null   &&  dbResult.DefaultAsDbColumn)
74                           if  (attr  !=   null   &&  attr.Ignore)
75                               continue ;
76                           else
77                              attr  =  attr  ??   new  DbColumnAttribute();
78                       else
79                           if  (attr  ==   null   ||  attr.Ignore)
80                               continue ;
81                       yield   return   new  DbColumnInfo(prop, attr);
82                  }
83              }
84 
85               #endregion
86 
87      }
88 

    这里，我们先建立一个DataReaderExtensions类，这个类的功能只有一个，给IDataReader添加一个Select<T>的方法，然后把思想转嫁给一个内部类EntityConverter<T>的Select方法（这个方法在那里？还没贴出来哪，别急），为什么用这么一个内部泛型类那？建议参考老赵的这篇文章，主要是出于性能方面的考虑。

    然后我们在通过GetProperties方法，获得关于这个实体类型的信息，放到一个叫DbColumnInfo的结构体里面（为什么用结构体哪？还是性能方面的考虑，减少垃圾对象，让GC过的轻松点）。这里的GetProperties方法就是一个彻头彻尾的普通反射，那么性能自然也就是手写代码的1/1000，不过别急，这个段代码对每个T而言仅仅跑1次，也就是说，某个类型Select过了，那么下一次，这个类型就不需要跑这个GetProperties方法了。

    不过，有一点不要误解，即使缓存了PropertyInfo，那也仅仅是减少了发现成员的代价，PropertyInfo.SetValue的代价依然是反射的标准代价，执行效率是1/1000。

    也就是说，之后的任务才是本文的重点内容，消除掉PropertyInfo.SetValue的代价，让我们的反射跑得飞起来。

    不过在这个之前，先把我们需要的一些IDataReader里面的方法先反射出来，做好缓存（放在DataReaderExtensions类里面，避免为每个T反射一次）：

 1           #region  Static Readonly Fields
 2           private   static   readonly  MethodInfo DataRecord_ItemGetter_Int  =
 3               typeof (IDataRecord).GetMethod( " get_Item " ,  new  Type[] {  typeof ( int ) });
 4           private   static   readonly  MethodInfo DataRecord_GetOrdinal  =
 5               typeof (IDataRecord).GetMethod( " GetOrdinal " );
 6           private   static   readonly  MethodInfo DataReader_Read  =
 7               typeof (IDataReader).GetMethod( " Read " );
 8           private   static   readonly  MethodInfo Convert_IsDBNull  =
 9               typeof (Convert).GetMethod( " IsDBNull " );
10           private   static   readonly  MethodInfo DataRecord_GetDateTime  =
11               typeof (IDataRecord).GetMethod( " GetDateTime " );
12           private   static   readonly  MethodInfo DataRecord_GetDecimal  =
13               typeof (IDataRecord).GetMethod( " GetDecimal " );
14           private   static   readonly  MethodInfo DataRecord_GetDouble  =
15               typeof (IDataRecord).GetMethod( " GetDouble " );
16           private   static   readonly  MethodInfo DataRecord_GetInt32  =
17               typeof (IDataRecord).GetMethod( " GetInt32 " );
18           private   static   readonly  MethodInfo DataRecord_GetInt64  =
19               typeof (IDataRecord).GetMethod( " GetInt64 " );
20           private   static   readonly  MethodInfo DataRecord_GetString  =
21               typeof (IDataRecord).GetMethod( " GetString " );
22           private   static   readonly  MethodInfo DataRecord_IsDBNull  =
23               typeof (IDataRecord).GetMethod( " IsDBNull " );
24           #endregion
25 

    接下来就是Emit了，但是鉴于其的难度比较高，就不仔细说明了，如果各位有兴趣，可以单独聊，这里就直接把这成堆的天书贴上来了（未处理short、byte、bool的情况，因为Oracle不支持这个类型，所以一直没写，同样枚举也只支持基础类型是int的或long的）：

  1               #region  Init Methods
  2 
  3               private   static  Converter < IDataReader, List < T >>  CreateBatchDataLoader(List < DbColumnInfo >  columnInfoes)
  4              {
  5                  DynamicMethod dm  =   new  DynamicMethod( string .Empty,  typeof (List < T > ),
  6                       new  Type[] {  typeof (IDataReader) },  typeof (EntityConverter < T > ));
  7                  ILGenerator il  =  dm.GetILGenerator();
  8                  LocalBuilder list  =  il.DeclareLocal( typeof (List < T > ));
  9                  LocalBuilder item  =  il.DeclareLocal( typeof (T));
 10                  Label exit  =  il.DefineLabel();
 11                  Label loop  =  il.DefineLabel();
 12                   //  List<T> list = new List<T>();
 13                  il.Emit(OpCodes.Newobj,  typeof (List < T > ).GetConstructor(Type.EmptyTypes));
 14                  il.Emit(OpCodes.Stloc_S, list);
 15                   //  [ int %index% = arg.GetOrdinal(%ColumnName%); ]
 16                  LocalBuilder[] colIndices  =  GetColumnIndices(il, columnInfoes);
 17                   //  while (arg.Read()) {
 18                  il.MarkLabel(loop);
 19                  il.Emit(OpCodes.Ldarg_0);
 20                  il.Emit(OpCodes.Callvirt, DataReader_Read);
 21                  il.Emit(OpCodes.Brfalse, exit);
 22                   //       T item = new T { %Property% =  };
 23                  BuildItem(il, columnInfoes, item, colIndices);
 24                   //       list.Add(item);
 25                  il.Emit(OpCodes.Ldloc_S, list);
 26                  il.Emit(OpCodes.Ldloc_S, item);
 27                  il.Emit(OpCodes.Callvirt,  typeof (List < T > ).GetMethod( " Add " ));
 28                   //  }
 29                  il.Emit(OpCodes.Br, loop);
 30                  il.MarkLabel(exit);
 31                   //  return list;
 32                  il.Emit(OpCodes.Ldloc_S, list);
 33                  il.Emit(OpCodes.Ret);
 34                   return  (Converter < IDataReader, List < T >> )dm.CreateDelegate( typeof (Converter < IDataReader, List < T >> ));
 35              }
 36 
 37               private   static  LocalBuilder[] GetColumnIndices(ILGenerator il, List < DbColumnInfo >  columnInfoes)
 38              {
 39                  LocalBuilder[] colIndices  =   new  LocalBuilder[columnInfoes.Count];
 40                   for  ( int  i  =   0 ; i  <  colIndices.Length; i ++ )
 41                  {
 42                       //  int %index% = arg.GetOrdinal(%ColumnName%);
 43                      colIndices[i]  =  il.DeclareLocal( typeof ( int ));
 44                      il.Emit(OpCodes.Ldarg_0);
 45                      il.Emit(OpCodes.Ldstr, columnInfoes[i].ColumnName);
 46                      il.Emit(OpCodes.Callvirt, DataRecord_GetOrdinal);
 47                      il.Emit(OpCodes.Stloc_S, colIndices[i]);
 48                  }
 49                   return  colIndices;
 50              }
 51 
 52               private   static   void  BuildItem(ILGenerator il, List < DbColumnInfo >  columnInfoes,
 53                  LocalBuilder item, LocalBuilder[] colIndices)
 54              {
 55                   //  T item = new T();
 56                  il.Emit(OpCodes.Newobj,  typeof (T).GetConstructor(Type.EmptyTypes));
 57                  il.Emit(OpCodes.Stloc_S, item);
 58                   for  ( int  i  =   0 ; i  <  colIndices.Length; i ++ )
 59                  {
 60                       if  (IsCompatibleType(columnInfoes[i].Type,  typeof ( int )))
 61                      {
 62                           //  item.%Property% = arg.GetInt32(%index%);
 63                          ReadInt32(il, item, columnInfoes, colIndices, i);
 64                      }
 65                       else   if  (IsCompatibleType(columnInfoes[i].Type,  typeof ( int ? )))
 66                      {
 67                           //  item.%Property% = arg.IsDBNull ? default(int?) : (int?)arg.GetInt32(%index%);
 68                          ReadNullableInt32(il, item, columnInfoes, colIndices, i);
 69                      }
 70                       else   if  (IsCompatibleType(columnInfoes[i].Type,  typeof ( long )))
 71                      {
 72                           //  item.%Property% = arg.GetInt64(%index%);
 73                          ReadInt64(il, item, columnInfoes, colIndices, i);
 74                      }
 75                       else   if  (IsCompatibleType(columnInfoes[i].Type,  typeof ( long ? )))
 76                      {
 77                           //  item.%Property% = arg.IsDBNull ? default(long?) : (long?)arg.GetInt64(%index%);
 78                          ReadNullableInt64(il, item, columnInfoes, colIndices, i);
 79                      }
 80                       else   if  (IsCompatibleType(columnInfoes[i].Type,  typeof ( decimal )))
 81                      {
 82                           //  item.%Property% = arg.GetDecimal(%index%);
 83                          ReadDecimal(il, item, columnInfoes[i].SetMethod, colIndices[i]);
 84                      }
 85                       else   if  (columnInfoes[i].Type  ==   typeof ( decimal ? ))
 86                      {
 87                           //  item.%Property% = arg.IsDBNull ? default(decimal?) : (int?)arg.GetDecimal(%index%);
 88                          ReadNullableDecimal(il, item, columnInfoes[i].SetMethod, colIndices[i]);
 89                      }
 90                       else   if  (columnInfoes[i].Type  ==   typeof (DateTime))
 91                      {
 92                           //  item.%Property% = arg.GetDateTime(%index%);
 93                          ReadDateTime(il, item, columnInfoes[i].SetMethod, colIndices[i]);
 94                      }
 95                       else   if  (columnInfoes[i].Type  ==   typeof (DateTime ? ))
 96                      {
 97                           //  item.%Property% = arg.IsDBNull ? default(DateTime?) : (int?)arg.GetDateTime(%index%);
 98                          ReadNullableDateTime(il, item, columnInfoes[i].SetMethod, colIndices[i]);
 99                      }
100                       else
101                      {
102                           //  item.%Property% = (%PropertyType%)arg[%index%];
103                          ReadObject(il, item, columnInfoes, colIndices, i);
104                      }
105                  }
106              }
107 
108               private   static   bool  IsCompatibleType(Type t1, Type t2)
109              {
110                   if  (t1  ==  t2)
111                       return   true ;
112                   if  (t1.IsEnum  &&  Enum.GetUnderlyingType(t1)  ==  t2)
113                       return   true ;
114                  var u1  =  Nullable.GetUnderlyingType(t1);
115                  var u2  =  Nullable.GetUnderlyingType(t2);
116                   if  (u1  !=   null   &&  u2  !=   null )
117                       return  IsCompatibleType(u1, u2);
118                   return   false ;
119              }
120 
121               private   static   void  ReadInt32(ILGenerator il, LocalBuilder item,
122                  List < DbColumnInfo >  columnInfoes, LocalBuilder[] colIndices,  int  i)
123              {
124                  il.Emit(OpCodes.Ldloc_S, item);
125                  il.Emit(OpCodes.Ldarg_0);
126                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
127                  il.Emit(OpCodes.Callvirt, DataRecord_GetInt32);
128                  il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
129              }
130 
131               private   static   void  ReadNullableInt32(ILGenerator il, LocalBuilder item,
132                  List < DbColumnInfo >  columnInfoes, LocalBuilder[] colIndices,  int  i)
133              {
134                  var local  =  il.DeclareLocal(columnInfoes[i].Type);
135                  Label intNull  =  il.DefineLabel();
136                  Label intCommon  =  il.DefineLabel();
137                  il.Emit(OpCodes.Ldloca, local);
138                  il.Emit(OpCodes.Ldarg_0);
139                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
140                  il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
141                  il.Emit(OpCodes.Brtrue_S, intNull);
142                  il.Emit(OpCodes.Ldarg_0);
143                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
144                  il.Emit(OpCodes.Callvirt, DataRecord_GetInt32);
145                  il.Emit(OpCodes.Call, columnInfoes[i].Type.GetConstructor(
146                       new  Type[] { Nullable.GetUnderlyingType(columnInfoes[i].Type) }));
147                  il.Emit(OpCodes.Br_S, intCommon);
148                  il.MarkLabel(intNull);
149                  il.Emit(OpCodes.Initobj, columnInfoes[i].Type);
150                  il.MarkLabel(intCommon);
151                  il.Emit(OpCodes.Ldloc_S, item);
152                  il.Emit(OpCodes.Ldloc, local);
153                  il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
154              }
155 
156               private   static   void  ReadInt64(ILGenerator il, LocalBuilder item,
157                  List < DbColumnInfo >  columnInfoes, LocalBuilder[] colIndices,  int  i)
158              {
159                  il.Emit(OpCodes.Ldloc_S, item);
160                  il.Emit(OpCodes.Ldarg_0);
161                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
162                  il.Emit(OpCodes.Callvirt, DataRecord_GetInt64);
163                  il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
164              }
165 
166               private   static   void  ReadNullableInt64(ILGenerator il, LocalBuilder item,
167                  List < DbColumnInfo >  columnInfoes, LocalBuilder[] colIndices,  int  i)
168              {
169                  var local  =  il.DeclareLocal(columnInfoes[i].Type);
170                  Label intNull  =  il.DefineLabel();
171                  Label intCommon  =  il.DefineLabel();
172                  il.Emit(OpCodes.Ldloca, local);
173                  il.Emit(OpCodes.Ldarg_0);
174                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
175                  il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
176                  il.Emit(OpCodes.Brtrue_S, intNull);
177                  il.Emit(OpCodes.Ldarg_0);
178                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
179                  il.Emit(OpCodes.Callvirt, DataRecord_GetInt64);
180                  il.Emit(OpCodes.Call, columnInfoes[i].Type.GetConstructor(
181                       new  Type[] { Nullable.GetUnderlyingType(columnInfoes[i].Type) }));
182                  il.Emit(OpCodes.Br_S, intCommon);
183                  il.MarkLabel(intNull);
184                  il.Emit(OpCodes.Initobj, columnInfoes[i].Type);
185                  il.MarkLabel(intCommon);
186                  il.Emit(OpCodes.Ldloc_S, item);
187                  il.Emit(OpCodes.Ldloc, local);
188                  il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
189              }
190 
191               private   static   void  ReadDecimal(ILGenerator il, LocalBuilder item,
192                  MethodInfo setMethod, LocalBuilder colIndex)
193              {
194                  il.Emit(OpCodes.Ldloc_S, item);
195                  il.Emit(OpCodes.Ldarg_0);
196                  il.Emit(OpCodes.Ldloc_S, colIndex);
197                  il.Emit(OpCodes.Callvirt, DataRecord_GetDecimal);
198                  il.Emit(OpCodes.Callvirt, setMethod);
199              }
200 
201               private   static   void  ReadNullableDecimal(ILGenerator il, LocalBuilder item,
202                  MethodInfo setMethod, LocalBuilder colIndex)
203              {
204                  var local  =  il.DeclareLocal( typeof ( decimal ? ));
205                  Label decimalNull  =  il.DefineLabel();
206                  Label decimalCommon  =  il.DefineLabel();
207                  il.Emit(OpCodes.Ldloca, local);
208                  il.Emit(OpCodes.Ldarg_0);
209                  il.Emit(OpCodes.Ldloc_S, colIndex);
210                  il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
211                  il.Emit(OpCodes.Brtrue_S, decimalNull);
212                  il.Emit(OpCodes.Ldarg_0);
213                  il.Emit(OpCodes.Ldloc_S, colIndex);
214                  il.Emit(OpCodes.Callvirt, DataRecord_GetDecimal);
215                  il.Emit(OpCodes.Call,  typeof ( decimal ? ).GetConstructor( new  Type[] {  typeof ( decimal ) }));
216                  il.Emit(OpCodes.Br_S, decimalCommon);
217                  il.MarkLabel(decimalNull);
218                  il.Emit(OpCodes.Initobj,  typeof ( decimal ? ));
219                  il.MarkLabel(decimalCommon);
220                  il.Emit(OpCodes.Ldloc_S, item);
221                  il.Emit(OpCodes.Ldloc, local);
222                  il.Emit(OpCodes.Callvirt, setMethod);
223              }
224 
225               private   static   void  ReadDateTime(ILGenerator il, LocalBuilder item,
226                  MethodInfo setMethod, LocalBuilder colIndex)
227              {
228                  il.Emit(OpCodes.Ldloc_S, item);
229                  il.Emit(OpCodes.Ldarg_0);
230                  il.Emit(OpCodes.Ldloc_S, colIndex);
231                  il.Emit(OpCodes.Callvirt, DataRecord_GetDateTime);
232                  il.Emit(OpCodes.Callvirt, setMethod);
233              }
234 
235               private   static   void  ReadNullableDateTime(ILGenerator il, LocalBuilder item,
236                  MethodInfo setMethod, LocalBuilder colIndex)
237              {
238                  var local  =  il.DeclareLocal( typeof (DateTime ? ));
239                  Label dtNull  =  il.DefineLabel();
240                  Label dtCommon  =  il.DefineLabel();
241                  il.Emit(OpCodes.Ldloca, local);
242                  il.Emit(OpCodes.Ldarg_0);
243                  il.Emit(OpCodes.Ldloc_S, colIndex);
244                  il.Emit(OpCodes.Callvirt, DataRecord_IsDBNull);
245                  il.Emit(OpCodes.Brtrue_S, dtNull);
246                  il.Emit(OpCodes.Ldarg_0);
247                  il.Emit(OpCodes.Ldloc_S, colIndex);
248                  il.Emit(OpCodes.Callvirt, DataRecord_GetDateTime);
249                  il.Emit(OpCodes.Call,  typeof (DateTime ? ).GetConstructor( new  Type[] {  typeof (DateTime) }));
250                  il.Emit(OpCodes.Br_S, dtCommon);
251                  il.MarkLabel(dtNull);
252                  il.Emit(OpCodes.Initobj,  typeof (DateTime ? ));
253                  il.MarkLabel(dtCommon);
254                  il.Emit(OpCodes.Ldloc_S, item);
255                  il.Emit(OpCodes.Ldloc, local);
256                  il.Emit(OpCodes.Callvirt, setMethod);
257              }
258 
259               private   static   void  ReadObject(ILGenerator il, LocalBuilder item,
260                  List < DbColumnInfo >  columnInfoes, LocalBuilder[] colIndices,  int  i)
261              {
262                  Label common  =  il.DefineLabel();
263                  il.Emit(OpCodes.Ldloc_S, item);
264                  il.Emit(OpCodes.Ldarg_0);
265                  il.Emit(OpCodes.Ldloc_S, colIndices[i]);
266                  il.Emit(OpCodes.Callvirt, DataRecord_ItemGetter_Int);
267                  il.Emit(OpCodes.Dup);
268                  il.Emit(OpCodes.Call, Convert_IsDBNull);
269                  il.Emit(OpCodes.Brfalse_S, common);
270                  il.Emit(OpCodes.Pop);
271                  il.Emit(OpCodes.Ldnull);
272                  il.MarkLabel(common);
273                  il.Emit(OpCodes.Unbox_Any, columnInfoes[i].Type);
274                  il.Emit(OpCodes.Callvirt, columnInfoes[i].SetMethod);
275              }
276 
277               #endregion
278 
279               #region  Internal Methods
280 
281               internal   static  List < T >  Select(IDataReader reader)
282              {
283                   return  BatchDataLoader(reader);
284              }
285 
286               #endregion
287 

    好，到这里，这个扩展方法已经完成了，来试用一下吧：

 1           public  List < MyClass >  GetList()
 2          {
 3              var reader  =  GetReader();
 4               return  reader.Select < MyClass > ();
 5          }
 6 
 7           public  IDataReader GetReader()
 8          {
 9               //  todo : GetReader
10               throw   new  NotImplementedException();
11          }
12 

    是不是很简单，大家不妨做个效率测试，看看是这段基于反射的代码效率高还是大家手写的效率高，以及填充到DataSet的效率，当然要注意数据的访问时间本身是不缺定的。（里面用了不少优化的访问方式，如果大家在处理IDataReader的手法不够娴熟的话，还真难说效率谁的高，呵呵）

（最后的示例代码里面忘记用using了。。。不改了，大家自己加上吧）