DataTable转化成实体对象

  1     /// <summary>
  2     /// The data extension.
  3     /// </summary>
  4     public static class DataExtension
  5     {
  6         /// <summary>
  7         /// ToList
  8         /// </summary>
  9         /// <typeparam name="T">T</typeparam>
 10         /// <param name="reader">reader</param>
 11         /// <returns>T</returns>
 12         public static List<T> ToList<T>(this IDataReader reader) where T : class, new()
 13         {
 14             var result = new List<T>();
 15 
 16             DataTable dt = reader.GetSchemaTable();
 17             try
 18             {
 19                 while (reader.Read())
 20                 {
 21                     var t = new T();
 22 
 23                     if (dt != null)
 24                     {
 25                         foreach (DataRow dr in dt.Rows)
 26                         {
 27                             // 当前列名&属性名
 28                             string columnName = dr[0].ToString();
 29                             PropertyInfo pro = typeof(T).GetProperty(columnName);
 30 
 31                             if (pro == null)
 32                             {
 33                                 continue;
 34                             }
 35 
 36                             if (!pro.CanWrite)
 37                             {
 38                                 continue;
 39                             }
 40 
 41                             pro.SetValue(t, ConvertExtension.ConvertHelper(reader[columnName], pro.PropertyType), null);
 42                         }
 43                     }
 44 
 45                     result.Add(t);
 46                 }
 47             }
 48             catch (System.Exception ex)
 49             {
 50                 throw ex;
 51             }
 52             finally
 53             {
 54                 if (!reader.IsClosed)
 55                 {
 56                     reader.Dispose();
 57                     reader.Close();
 58                 }
 59             }
 60 
 61             return result;
 62         }
 63 
 64         /// <summary>
 65         /// ToList
 66         /// </summary>
 67         /// <typeparam name="T">T</typeparam>
 68         /// <param name="dt">dt</param>
 69         /// <returns>T</returns>
 70         public static List<T> ToList<T>(this DataTable dt) where T : class, new()
 71         {
 72             var result = new List<T>();
 73             foreach (DataRow dr in dt.Rows)
 74             {
 75                 var t = new T();
 76                 try
 77                 {
 78                     foreach (DataColumn column in dt.Columns)
 79                     {
 80                         // 当前列名&属性名
 81                         string columnName = column.ColumnName;
 82                         PropertyInfo pro = typeof(T).GetProperty(columnName);
 83 
 84                         if (pro == null)
 85                         {
 86                             continue;
 87                         }
 88 
 89                         if (!pro.CanWrite)
 90                         {
 91                             continue;
 92                         }
 93 
 94                         pro.SetValue(t, ConvertExtension.ConvertHelper(dr[columnName], pro.PropertyType), null);
 95                     }
 96                 }
 97                 catch (System.Exception ex)
 98                 {
 99                     throw ex;
100                 }
101 
102                 result.Add(t);
103             }
104 
105             return result;
106         }
107 
108         /// <summary>
109         /// ToList
110         /// </summary>
111         /// <typeparam name="T">T</typeparam>
112         /// <param name="ds">ds</param>
113         /// <returns>T</returns>
114         public static List<T> ToList<T>(this DataSet ds) where T : class, new()
115         {
116             return ds.Tables[0].ToList<T>();
117         }
118 
119         /// <summary>
120         /// ToList
121         /// </summary>
122         /// <typeparam name="T">T</typeparam>
123         /// <param name="ds">ds</param>
124         /// <param name="dataTableIndex">dataTableIndex</param>
125         /// <returns>T</returns>
126         public static List<T> ToList<T>(this DataSet ds, int dataTableIndex) where T : class, new()
127         {
128             return ds.Tables[dataTableIndex].ToList<T>();
129         }
130 
131         /// <summary>
132         /// ToModel
133         /// </summary>
134         /// <typeparam name="T">T</typeparam>
135         /// <param name="reader">reader</param>
136         /// <returns>T</returns>
137         public static T ToModel<T>(this IDataReader reader) where T : class, new()
138         {
139             var t = new T();
140             DataTable dt = reader.GetSchemaTable();
141             try
142             {
143                 while (reader.Read())
144                 {
145                     if (dt != null)
146                     {
147                         foreach (DataRow dr in dt.Rows)
148                         {
149                             // 当前列名&属性名
150                             string columnName = dr[0].ToString();
151                             PropertyInfo pro = typeof(T).GetProperty(columnName);
152 
153                             if (pro == null)
154                             {
155                                 continue;
156                             }
157 
158                             if (!pro.CanWrite)
159                             {
160                                 continue;
161                             }
162 
163                             pro.SetValue(t, ConvertExtension.ConvertHelper(reader[columnName], pro.PropertyType), null);
164                         }
165                     }
166                 }
167             }
168             catch (System.Exception ex)
169             {
170                 throw ex;
171             }
172             finally
173             {
174                 if (!reader.IsClosed)
175                 {
176                     reader.Dispose();
177                     reader.Close();
178                 }
179             }
180 
181             return t;
182         }
183 
184         /// <summary>
185         /// ToModel
186         /// </summary>
187         /// <typeparam name="T">T</typeparam>
188         /// <param name="dt">dt</param>
189         /// <returns>T</returns>
190         public static T ToModel<T>(this DataTable dt) where T : class, new()
191         {
192             var t = new T();
193             if (dt.Rows.Count <= 0)
194             {
195                 return t;
196             }
197 
198             try
199             {
200                 foreach (DataColumn column in dt.Columns)
201                 {
202                     // 当前列名&属性名
203                     string columnName = column.ColumnName;
204                     PropertyInfo pro = typeof(T).GetProperty(columnName);
205                     if (pro == null)
206                     {
207                         continue;
208                     }
209 
210                     if (!pro.CanWrite)
211                     {
212                         continue;
213                     }
214 
215                     pro.SetValue(t, ConvertExtension.ConvertHelper(dt.Rows[0][columnName], pro.PropertyType), null);
216                 }
217             }
218             catch (System.Exception ex)
219             {
220                 throw ex;
221             }
222 
223             return t;
224         }
225 
226         /// <summary>
227         /// ToModel
228         /// </summary>
229         /// <typeparam name="T">T</typeparam>
230         /// <param name="ds">ds</param>
231         /// <param name="dataTableIndex">dataTableIndex</param>
232         /// <returns>T</returns>
233         public static T ToModel<T>(this DataSet ds, int dataTableIndex = 0) where T : class, new()
234         {
235             return ds.Tables[0].ToModel<T>();
236         }
237     }
DataExtension
  1     /// <summary>
  2     /// The convert extension.
  3     /// </summary>
  4     public static class ConvertExtension
  5     {
  6         /// <summary>
  7         /// The convert helper.
  8         /// </summary>
  9         /// <param name="value">
 10         /// The value.
 11         /// </param>
 12         /// <param name="conversionType">
 13         /// The conversion type.
 14         /// </param>
 15         /// <returns>
 16         /// The <see cref="object"/>.
 17         /// </returns>
 18         public static object ConvertHelper(object value, Type conversionType)
 19         {
 20             Type nullableType = Nullable.GetUnderlyingType(conversionType);
 21 
 22             // 判断当前类型是否可为 null
 23             if (nullableType != null)
 24             {
 25                 if (value == DBNull.Value)
 26                 {
 27                     return null;
 28                 }
 29 
 30                 // 若是枚举 则先转换为枚举
 31                 if (nullableType.IsEnum)
 32                 {
 33                     value = System.Enum.Parse(nullableType, value.ToString());
 34                 }
 35 
 36                 return Convert.ChangeType(value, nullableType);
 37             }
 38 
 39             if (conversionType.IsEnum)
 40             {
 41                 return System.Enum.Parse(conversionType, value.ToString());
 42             }
 43 
 44             return Convert.ChangeType(value, conversionType);
 45         }
 46 
 47         /// <summary>
 48         /// The convert to decimal null.
 49         /// </summary>
 50         /// <param name="targetObj">
 51         /// The target obj.
 52         /// </param>
 53         /// <returns>
 54         /// The <see cref="decimal"/>.
 55         /// </returns>
 56         public static decimal? ConvertToDecimalNull(object targetObj)
 57         {
 58             if (targetObj == null || targetObj == DBNull.Value)
 59             {
 60                 return null;
 61             }
 62 
 63             return Convert.ToDecimal(targetObj);
 64         }
 65 
 66         /// <summary>
 67         /// The convert to int null.
 68         /// </summary>
 69         /// <param name="targetObj">
 70         /// The target obj.
 71         /// </param>
 72         /// <returns>
 73         /// The <see cref="int"/>.
 74         /// </returns>
 75         public static int? ConvertToIntNull(object targetObj)
 76         {
 77             if (targetObj == null || targetObj == DBNull.Value)
 78             {
 79                 return null;
 80             }
 81 
 82             return Convert.ToInt32(targetObj);
 83         }
 84 
 85         /// <summary>
 86         /// The convert to string.
 87         /// </summary>
 88         /// <param name="obj">
 89         /// The obj.
 90         /// </param>
 91         /// <returns>
 92         /// The <see cref="string"/>.
 93         /// </returns>
 94         public static string ConvertToString(object obj)
 95         {
 96             return obj == null ? string.Empty : obj.ToString();
 97         }
 98 
 99         /// <summary>
100         /// 将泛类型集合List类转换成DataTable
101         /// </summary>
102         /// <param name="entitys">泛类型集合</param>
103         /// <typeparam name="T">T</typeparam>
104         /// <returns>DataTable</returns>
105         public static DataTable ListToDataTable<T>(List<T> entitys)
106         {
107             // 检查实体集合不能为空
108             if (entitys == null || entitys.Count < 1)
109             {
110                 throw new System.Exception("需转换的集合为空");
111             }
112 
113             // 取出第一个实体的所有Propertie
114             Type entityType = entitys[0].GetType();
115             PropertyInfo[] entityProperties = entityType.GetProperties();
116 
117             // 生成DataTable的structure
118             // 生产代码中,应将生成的DataTable结构Cache起来,此处略
119             DataTable dt = new DataTable();
120             foreach (PropertyInfo t in entityProperties)
121             {
122                 // dt.Columns.Add(entityProperties[i].Name, entityProperties[i].PropertyType);
123                 dt.Columns.Add(t.Name);
124             }
125 
126             // 将所有entity添加到DataTable中
127             foreach (object entity in entitys)
128             {
129                 // 检查所有的的实体都为同一类型
130                 if (entity.GetType() != entityType)
131                 {
132                     throw new System.Exception("要转换的集合元素类型不一致");
133                 }
134 
135                 object[] entityValues = new object[entityProperties.Length];
136                 for (int i = 0; i < entityProperties.Length; i++)
137                 {
138                     entityValues[i] = entityProperties[i].GetValue(entity, null);
139                 }
140 
141                 dt.Rows.Add(entityValues);
142             }
143 
144             return dt;
145         }
146 
147         /// <summary>
148         /// 转换中文星期
149         /// </summary>
150         /// <param name="dt">The dt.</param>
151         /// <returns>Week.</returns>
152         public static Week ConverToWeekByZHCN(this DateTime dt)
153         {
154             return (Week)dt.DayOfWeek;
155         }
156 
157         /// <summary>
158         /// 四舍五入保留2位小数(中国式)
159         /// </summary>
160         /// <param name="d"></param>
161         /// <returns></returns>
162         public static decimal DecimalTwoPlaces(this decimal d)
163         {
164             return Math.Round(d, 2, MidpointRounding.AwayFromZero);
165         }
166     }
ConvertExtension

 

将 IDataReader DataSet DataTable 转化成 List<T> Or T类型
上面是转化代码

posted @ 2015-06-09 13:42  刘小吉  阅读(450)  评论(0编辑  收藏  举报