当前位置: 亚洲城ca88 > ca88 > 正文

C#中DataTable转化为List<T>解析

时间:2019-05-03 16:39来源:ca88
   在.net项目中接纳到DataTable和ListT集结的地点较多, 泛型的裨益:它为使用c#言语编写面向对象程序增添了非常大的效劳和灵活性。不会残忍对值类型实行装箱和拆箱,或对引用类型

    在.net项目中接纳到DataTable和List<T>集结的地点较多, 泛型的裨益: 它为使用c#言语编写面向对象程序增添了非常大的效劳和灵活性。不会残忍对值类型实行装箱和拆箱,或对引用类型实行。当提到到两者之间的调换时,就显得有点比较麻烦。那些里面包车型客车难题首要在双方的积攒格局,DataTable的贮存格局利用1种二维表的点子实行多少的积累操作,DataTable表示内部存储器中数据的3个表。在List集结中,List的本色就是二个数组,则运用壹种线性结构对数据开始展览仓库储存。

      在.net项目中利用到DataTable和List会集的地点较多, 泛型的补益: 它为使用c#ca88,言语编写面向对象程序扩大了特大的坚守和灵活性。不会冷酷对值类型实行李装运箱和拆箱,或对引用类型举行。当提到到两者之间的调换时,就展现略微相比较麻烦。

    在.net项目中选择到DataTable和List<T>集合的地点较多, 泛型的裨益: 它为使用c#言语编写面向对象程序扩展了高大的效劳和灵活性。不会狂暴对值类型举办李装运箱和拆箱,或对引用类型举行。当提到到两者之间的调换时,就呈现略微比较麻烦。那么些里面包车型客车标题主要在两方的积攒情势,DataTable的贮存形式使用一种2维表的诀窍张开数量的积攒操作,DataTable代表内部存款和储蓄器中数据的三个表。在List集合中,List的本来面目正是多个数组,则运用一种线性结构对数据实行仓库储存。

   在转移进度中,首要的难点在于不相同门类的拍卖上,首要分为值类型和引用类型两大类。

     那么些里面包车型客车难题关键在互相的囤积形式,DataTable的囤积格局利用一种2维表的方法开始展览多少的存款和储蓄操作,DataTable表示内部存款和储蓄器中数据的八个表。在List集结中,List的原形正是3个数组,则使用一种线性结构对数码进行仓库储存。

   在转移进度中,主要的主题材料在于差异品种的拍卖上,主要分为值类型和引用类型两大类。

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

     在转变进程中,首要的难点在于分歧品类的管理上,主要分为值类型和引用类型两大类。

       C#中值类型总是含有相应该类型的贰个值,指类型涵盖:轻易类型(Simple types ),结构类型(struct types),枚举类型(Enumeration types)。

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

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

       轻松类型涵盖:整型,布尔型,字符型 (整型的壹种奇特情形),浮点型,小数型。

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

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

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

       引用类型:引用类型不存款和储蓄它们所表示的实际上数目,但它们存款和储蓄实际数目的引用。主要含有:对象类型,类类 型,接口,代表元,字符串类型,数组。

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

       引用类型:引用类型不存款和储蓄它们所代表的实在多少,但它们存款和储蓄实际多少的引用。首要涵盖:对象类型,类类 型,接口,代表元,字符串类型,数组。

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

     引用类型:引用类型不存款和储蓄它们所表示的骨子里多少,但它们存款和储蓄实际多少的引用。主要涵盖:对象类型,类类 型,接口,代表元,字符串类型,数组。

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

一.类型枚举:

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

1.类型枚举:

       /// <summary>
        /// 类型枚举
        /// </summary>
        private enum ModelType
        {
            //值类型
            Struct,
            Enum,
            //引用类型
            String,
            Object,
            Else
        }


        private static ModelType GetModelType(Type modelType)
        {
            //值类型
            if (modelType.IsEnum)
            {
                return ModelType.Enum;
            }
            //值类型
            if (modelType.IsValueType)
            {
                return ModelType.Struct;
            }
            //引用类型 特殊类型处理
            if (modelType == typeof(string))
            {
                return ModelType.String;
            }
            //引用类型 特殊类型处理
            return modelType == typeof(object) ? ModelType.Object : ModelType.Else;
        }

1.类型枚举:

       /// <summary>
        /// 类型枚举
        /// </summary>
        private enum ModelType
        {
            //值类型
            Struct,
            Enum,
            //引用类型
            String,
            Object,
            Else
        }


        private static ModelType GetModelType(Type modelType)
        {
            //值类型
            if (modelType.IsEnum)
            {
                return ModelType.Enum;
            }
            //值类型
            if (modelType.IsValueType)
            {
                return ModelType.Struct;
            }
            //引用类型 特殊类型处理
            if (modelType == typeof(string))
            {
                return ModelType.String;
            }
            //引用类型 特殊类型处理
            return modelType == typeof(object) ? ModelType.Object : ModelType.Else;
        }

 

ca88 1

 

2.有血有肉的调换操作方法:

2.实际的转移操作方法:

二.切实的调换操作方法:

        /// <summary>
        /// datatable转换为List<T>集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="table"></param>
        /// <returns></returns>
        public static List<T> DataTableToList<T>(DataTable table)
        {
            var list = new List<T>();
            foreach (DataRow item in table.Rows)
            {
                list.Add(DataRowToModel<T>(item));
            }
            return list;
        }

        public static T DataRowToModel<T>(DataRow row)
        {
            T model;
            var type = typeof(T);
            var modelType = GetModelType(type);
            switch (modelType)
            {
                //值类型
                case ModelType.Struct:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //值类型
                case ModelType.Enum:
                    {
                        model = default(T);
                        if (row[0] != null)
                        {
                            var fiType = row[0].GetType();
                            if (fiType == typeof(int))
                            {
                                model = (T)row[0];
                            }
                            else if (fiType == typeof(string))
                            {
                                model = (T)Enum.Parse(typeof(T), row[0].ToString());
                            }
                        }
                    }
                    break;
                //引用类型 c#对string也当做值类型处理
                case ModelType.String:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用类型 直接返回第一行第一列的值
                case ModelType.Object:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用类型
                case ModelType.Else:
                    {
                        //引用类型 必须对泛型实例化
                        model = Activator.CreateInstance<T>();
                        //获取model中的属性
                        var modelPropertyInfos = type.GetProperties();
                        //遍历model每一个属性并赋值DataRow对应的列
                        foreach (var pi in modelPropertyInfos)
                        {
                            //获取属性名称
                            var name = pi.Name;
                            if (!row.Table.Columns.Contains(name) || row[name] == null) continue;
                            var piType = GetModelType(pi.PropertyType);
                            switch (piType)
                            {
                                case ModelType.Struct:
                                    {
                                        var value = Convert.ChangeType(row[name], pi.PropertyType);
                                        pi.SetValue(model, value, null);
                                    }
                                    break;
                                case ModelType.Enum:
                                    {
                                        var fiType = row[0].GetType();
                                        if (fiType == typeof(int))
                                        {
                                            pi.SetValue(model, row[name], null);
                                        }
                                        else if (fiType == typeof(string))
                                        {
                                            var value = (T)Enum.Parse(typeof(T), row[name].ToString());
                                            if (value != null)
                                                pi.SetValue(model, value, null);
                                        }
                                    }
                                    break;
                                case ModelType.String:
                                    {
                                        var value = Convert.ChangeType(row[name], pi.PropertyType);
                                        pi.SetValue(model, value, null);
                                    }
                                    break;
                                case ModelType.Object:
                                    {
                                        pi.SetValue(model, row[name], null);
                                    }
                                    break;
                                case ModelType.Else:
                                    throw new Exception("不支持该类型转换");
                                default:
                                    throw new Exception("未知类型");
                            }
                        }
                    }
                    break;
                default:
                    model = default(T);
                    break;
            }
            return model;
        }

ca88 2

        /// <summary>
        /// datatable转换为List<T>集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="table"></param>
        /// <returns></returns>
        public static List<T> DataTableToList<T>(DataTable table)
        {
            var list = new List<T>();
            foreach (DataRow item in table.Rows)
            {
                list.Add(DataRowToModel<T>(item));
            }
            return list;
        }

        public static T DataRowToModel<T>(DataRow row)
        {
            T model;
            var type = typeof(T);
            var modelType = GetModelType(type);
            switch (modelType)
            {
                //值类型
                case ModelType.Struct:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //值类型
                case ModelType.Enum:
                    {
                        model = default(T);
                        if (row[0] != null)
                        {
                            var fiType = row[0].GetType();
                            if (fiType == typeof(int))
                            {
                                model = (T)row[0];
                            }
                            else if (fiType == typeof(string))
                            {
                                model = (T)Enum.Parse(typeof(T), row[0].ToString());
                            }
                        }
                    }
                    break;
                //引用类型 c#对string也当做值类型处理
                case ModelType.String:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用类型 直接返回第一行第一列的值
                case ModelType.Object:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用类型
                case ModelType.Else:
                    {
                        //引用类型 必须对泛型实例化
                        model = Activator.CreateInstance<T>();
                        //获取model中的属性
                        var modelPropertyInfos = type.GetProperties();
                        //遍历model每一个属性并赋值DataRow对应的列
                        foreach (var pi in modelPropertyInfos)
                        {
                            //获取属性名称
                            var name = pi.Name;
                            if (!row.Table.Columns.Contains(name) || row[name] == null) continue;
                            var piType = GetModelType(pi.PropertyType);
                            switch (piType)
                            {
                                case ModelType.Struct:
                                    {
                                        var value = Convert.ChangeType(row[name], pi.PropertyType);
                                        pi.SetValue(model, value, null);
                                    }
                                    break;
                                case ModelType.Enum:
                                    {
                                        var fiType = row[0].GetType();
                                        if (fiType == typeof(int))
                                        {
                                            pi.SetValue(model, row[name], null);
                                        }
                                        else if (fiType == typeof(string))
                                        {
                                            var value = (T)Enum.Parse(typeof(T), row[name].ToString());
                                            if (value != null)
                                                pi.SetValue(model, value, null);
                                        }
                                    }
                                    break;
                                case ModelType.String:
                                    {
                                        var value = Convert.ChangeType(row[name], pi.PropertyType);
                                        pi.SetValue(model, value, null);
                                    }
                                    break;
                                case ModelType.Object:
                                    {
                                        pi.SetValue(model, row[name], null);
                                    }
                                    break;
                                case ModelType.Else:
                                    throw new Exception("不支持该类型转换");
                                default:
                                    throw new Exception("未知类型");
                            }
                        }
                    }
                    break;
                default:
                    model = default(T);
                    break;
            }
            return model;
        }

    以上的操作中,对两样体系有相应的管理方式。

ca88 3

    以上的操作中,对两样门类有相应的管理格局。

上述的操作中,对不相同连串有相应的管理格局。

编辑:ca88 本文来源:C#中DataTable转化为List&lt;T&gt;解析

关键词: 亚洲城ca88