C#读取数据库返回泛型集合（DataSetToList）

一般我们用使用ADO.NET查询数据库返回泛型集合?使用SqlDataReader逐行读取数据存入对象

1. /// <summary> 
2.         /// 获取UserInfo泛型集合 
3.         /// </summary> 
4.         /// <param name="connStr">数据库连接字符串</param> 
5.         /// <param name="sqlStr">要查询的T-SQL</param> 
6.         /// <returns></returns> 
7.         public IList<UserInfo> GetUserInfoAll(string connStr, string sqlStr) 
8.         { 
9.             using (SqlConnection conn = new SqlConnection(connStr)) 
10.             { 
11.                 using (SqlCommand cmd = new SqlCommand(sqlStr,conn)) 
12.                 { 
13.                     SqlDataReader sdr = cmd.ExecuteReader(); 
14.                     IList<UserInfo> list = new List<UserInfo>(); 
15.                     while (sdr.Read()) 
16.                     { 
17.                         UserInfo userInfo = new UserInfo(); 
18.                         userInfo.ID = (Guid) sdr["ID"]; 
19.                         userInfo.LoginName = sdr["LoginName"].ToString(); 
20.                         userInfo.LoginPwd = sdr["LoginPwd"].ToString(); 
21.                         list.Add(userInfo); 
22.                     } 
23.                     return list; 
24.                 } 
25.             } 
26.         } 

这样做虽然返回了需要的数据，但如果当数据库表非常多的时候，针对每一个表都需要去建立这样的一个方法，非常麻烦，也增加了重复劳动力。

而直接返回DataSet操作起来又不方便，DataSet是一种弱类型。也不如泛型集合操作效率高！

这个时候就需要我们来提取一个通用的转换方法了?DataSetToList。

1. /// <summary> 
2.        /// 获取泛型集合 
3.        /// </summary> 
4.        /// <typeparam name="T">类型</typeparam> 
5.        /// <param name="connStr">数据库连接字符串</param> 
6.        /// <param name="sqlStr">要查询的T-SQL</param> 
7.        /// <returns></returns> 
8.         public IList<T> GetList<T>(string connStr, string sqlStr) 
9.        { 
10.            using (SqlConnection conn = new SqlConnection(connStr)) 
11.            { 
12.                using (SqlDataAdapter sda = new SqlDataAdapter(sqlStr, conn)) 
13.                { 
14.                    DataSet ds = new DataSet(); 
15.                    sda.Fill(ds); 
16.                    return DataSetToList<T>(ds, 0); 
17.                } 
18.            } 
19.  
20. } 

1. /// <summary> 
2. /// DataSetToList 
3. /// </summary> 
4. /// <typeparam name="T">转换类型</typeparam> 
5. /// <param name="dataSet">数据源</param> 
6. /// <param name="tableIndex">需要转换表的索引</param> 
7. /// <returns>泛型集合</returns> 
8.  public IList<T> DataSetToList<T>(DataSet dataSet, int tableIndex) 
9. { 
10.     //确认参数有效 
11.      if (dataSet == null || dataSet.Tables.Count <= 0 || tableIndex < 0) 
12.         return null; 
13.  
14.     DataTable dt = dataSet.Tables[tableIndex]; 
15.  
16.     IList<T> list = new List<T>(); 
17.  
18.  
19.     for (int i = 0; i < dt.Rows.Count; i++) 
20.     { 
21.         //创建泛型对象 
22.          T _t = Activator.CreateInstance<T>(); 
23.  
24.         //获取对象所有属性 
25.          PropertyInfo propertyInfo = _t.GetType().GetProperties(); 
26.  
27.         for (int j = 0; j < dt.Columns.Count; j++) 
28.         { 
29.             foreach (PropertyInfo info in propertyInfo) 
30.             { 
31.                 //属性名称和列名相同时赋值 
32.                 if (dt.Columns[j].ColumnName.ToUpper().Equals(info.Name.ToUpper())) 
33.                 { 
34.                     if (dt.Rows[i][j]!=DBNull.Value) 
35.                     { 
36.                         info.SetValue(_t, dt.Rows[i][j], null); 
37.                     } 
38.                     else 
39.                     { 
40.                         info.SetValue(_t, null, null); 
41.                     } 
42.                      
43.                     break; 
44.                 } 
45.             } 
46.         } 
47.         list.Add(_t); 
48.     } 
49.     return list; 
50. } 

使用这种转换方式需要注意的是实体类（model）的属性必须和数据库表的字段名字一致（大小写可以不考虑）；

因为转换时候的匹配是靠属性名称和字段名称匹配的；

当然如果项目中用到了Linq to Sql 的话就不必这种转换，Linq 已经封装好了；