zoukankan      html  css  js  c++  java
  • 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类型
    上面是转化代码

  • 相关阅读:
    HDU 1082 Matrix Chain Multiplication
    HDU 1086 You can Solve a Geometry Problem too
    HDU 1099 Lottery
    jquery正则检测字符串表达式的合法性
    Like语句中的注入
    HDU 1372 Knight Moves
    HDU 1253 胜利大逃亡
    HDU 1242 Rescue
    我有新博客啦
    水平越权与垂直越权
  • 原文地址:https://www.cnblogs.com/liuxiaoji/p/4563305.html
Copyright © 2011-2022 走看看