C#中DataTable转化为List解析

  • 2,016
  • 阅读模式

在.net项目中使用到DataTable和List集合的地方较多, 泛型的好处: 它为使用c#语言编写面向对象程序增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱,或对引用类型进行。当涉及到两者之间的转换时,就显得有些较为繁琐。这个其中的问题主要在两者的存储方式,DataTable的存储方式采用一种二维表的方式进行数据的存储操作,DataTable表示内存中数据的一个表。在List集合中,List的本质就是一个数组,则采用一种线性结构对数据进行存储。

在转换过程中,主要的问题在于不同类型的处理上,主要分为值类型和引用类型两大类。

C#中值类型总是含有相应该类型的一个值,指类型包含:简单类型(Simple types ),结构类型(struct types),枚举类型(Enumeration types)。

简单类型包含:整型,布尔型,字符型 (整型的一种特殊情况),浮点型,小数型。

整型包含: sbyte 、byte、 short、 ushort、 int、 uint、 long、 ulong 和 char。

引用类型:引用类型不存储它们所代表的实际数据,但它们存储实际数据的引用。主要包含:对象类型,类类 型,接口,代表元,字符串类型,数组。

现提供转换的代码,仅供参考:

1.类型枚举:

  1. /// <summary>
  2.         /// 类型枚举
  3.         /// </summary>
  4.         private enum ModelType
  5.         {
  6.             //值类型
  7.             Struct,
  8.             Enum,
  9.             //引用类型
  10.             String,
  11.             Object,
  12.             Else
  13.         }
  14.         private static ModelType GetModelType(Type modelType)
  15.         {
  16.             //值类型
  17.             if (modelType.IsEnum)
  18.             {
  19.                 return ModelType.Enum;
  20.             }
  21.             //值类型
  22.             if (modelType.IsValueType)
  23.             {
  24.                 return ModelType.Struct;
  25.             }
  26.             //引用类型 特殊类型处理
  27.             if (modelType == typeof(string))
  28.             {
  29.                 return ModelType.String;
  30.             }
  31.             //引用类型 特殊类型处理
  32.             return modelType == typeof(object) ? ModelType.Object : ModelType.Else;
  33.         }

2.具体的转换操作方法:

  1. /// <summary>
  2.         /// datatable转换为List<T>集合
  3.         /// </summary>
  4.         /// <typeparam name="T"></typeparam>
  5.         /// <param name="table"></param>
  6.         /// <returns></returns>
  7.         public static List<T> DataTableToList<T>(DataTable table)
  8.         {
  9.             var list = new List<T>();
  10.             foreach (DataRow item in table.Rows)
  11.             {
  12.                 list.Add(DataRowToModel<T>(item));
  13.             }
  14.             return list;
  15.         }
  16.         public static T DataRowToModel<T>(DataRow row)
  17.         {
  18.             T model;
  19.             var type = typeof(T);
  20.             var modelType = GetModelType(type);
  21.             switch (modelType)
  22.             {
  23.                 //值类型
  24.                 case ModelType.Struct:
  25.                     {
  26.                         model = default(T);
  27.                         if (row[0] != null)
  28.                             model = (T)row[0];
  29.                     }
  30.                     break;
  31.                 //值类型
  32.                 case ModelType.Enum:
  33.                     {
  34.                         model = default(T);
  35.                         if (row[0] != null)
  36.                         {
  37.                             var fiType = row[0].GetType();
  38.                             if (fiType == typeof(int))
  39.                             {
  40.                                 model = (T)row[0];
  41.                             }
  42.                             else if (fiType == typeof(string))
  43.                             {
  44.                                 model = (T)Enum.Parse(typeof(T), row[0].ToString());
  45.                             }
  46.                         }
  47.                     }
  48.                     break;
  49.                 //引用类型 c#对string也当做值类型处理
  50.                 case ModelType.String:
  51.                     {
  52.                         model = default(T);
  53.                         if (row[0] != null)
  54.                             model = (T)row[0];
  55.                     }
  56.                     break;
  57.                 //引用类型 直接返回第一行第一列的值
  58.                 case ModelType.Object:
  59.                     {
  60.                         model = default(T);
  61.                         if (row[0] != null)
  62.                             model = (T)row[0];
  63.                     }
  64.                     break;
  65.                 //引用类型
  66.                 case ModelType.Else:
  67.                     {
  68.                         //引用类型 必须对泛型实例化
  69.                         model = Activator.CreateInstance<T>();
  70.                         //获取model中的属性
  71.                         var modelPropertyInfos = type.GetProperties();
  72.                         //遍历model每一个属性并赋值DataRow对应的列
  73.                         foreach (var pi in modelPropertyInfos)
  74.                         {
  75.                             //获取属性名称
  76.                             var name = pi.Name;
  77.                             if (!row.Table.Columns.Contains(name) || row[name] == nullcontinue;
  78.                             var piType = GetModelType(pi.PropertyType);
  79.                             switch (piType)
  80.                             {
  81.                                 case ModelType.Struct:
  82.                                     {
  83.                                         var value = Convert.ChangeType(row[name], pi.PropertyType);
  84.                                         pi.SetValue(model, value, null);
  85.                                     }
  86.                                     break;
  87.                                 case ModelType.Enum:
  88.                                     {
  89.                                         var fiType = row[0].GetType();
  90.                                         if (fiType == typeof(int))
  91.                                         {
  92.                                             pi.SetValue(model, row[name], null);
  93.                                         }
  94.                                         else if (fiType == typeof(string))
  95.                                         {
  96.                                             var value = (T)Enum.Parse(typeof(T), row[name].ToString());
  97.                                             if (value != null)
  98.                                                 pi.SetValue(model, value, null);
  99.                                         }
  100.                                     }
  101.                                     break;
  102.                                 case ModelType.String:
  103.                                     {
  104.                                         var value = Convert.ChangeType(row[name], pi.PropertyType);
  105.                                         pi.SetValue(model, value, null);
  106.                                     }
  107.                                     break;
  108.                                 case ModelType.Object:
  109.                                     {
  110.                                         pi.SetValue(model, row[name], null);
  111.                                     }
  112.                                     break;
  113.                                 case ModelType.Else:
  114.                                     throw new Exception("不支持该类型转换");
  115.                                 default:
  116.                                     throw new Exception("未知类型");
  117.                             }
  118.                         }
  119.                     }
  120.                     break;
  121.                 default:
  122.                     model = default(T);
  123.                     break;
  124.             }
  125.             return model;
  126.         }

以上的操作中,对不同类型有对应的处理方式。

爱知求真,静心钻研,务实创新!

weinxin
我的微信
这是我的微信扫一扫
开拓者博主
  • 本文由 发表于 2016年10月18日20:03:09
  • 转载请务必保留本文链接:https://www.150643.com/372.html
匿名

发表评论

匿名网友 填写信息