怎么讲DataSet转化为List<T>

Question

如题

Answer 1

怎么讲DataSet转化为List<T>

Answer 2

ds.Tables[0].AsEnumerable().ToList<T>();

Answer 3

补充
添加命名空间using system.data;
using system.linq;

Answer 4

public IList <T> GetList <T>(DataTable table)   
  {   
  IList <T> list = new List <T>();   
  T t = default(T);   
  PropertyInfo[] propertypes = null;   
  string tempName = string.Empty;   
  foreach (DataRow row in table.Rows)   
  {   
  t = Activator.CreateInstance <T>();   
  propertypes = t.GetType().GetProperties();   
  foreach (PropertyInfo pro in propertypes)   
  {   
  tempName = pro.Name;   
  if (table.Columns.Contains(tempName))   
  {   
  object value = row[tempName];   
  pro.SetValue(t, value, null);   
  }   
  }   
  list.Add(t);   
  }   
  return list;   
  }   

Answer 5

如果你学会了Linq，大多数时候可以直接写出实在的清晰代码，例如：var result = dt.Rows
    .OfType<DataRow>()
    .Select(row => new Student
    {
        姓名 = (string)row["xingming"],
        班级 = (string)row["banji"],
        总成绩 = (int)row["chengji"]
    });
而且，这个result可以继续用于附加更为复杂的Linq查询，等等。它是延迟执行的，只有到你枚举出它的结果时才会真正开始执行。

Answer 6

比如说，除了result.ToList()得到List<Student>类型的结果，还可以执行result.ToDictionary，result.ToArray等等操作。其实有了Linq，那么根本不需要再去什么什么DataTable、DataSet了。

Answer 7

5楼的方法要保证T的属性名和列名一致才可以。
通用方法就是这样，
循环datarow，实例化T，list.add（T）

Answer 8

基本上，用户都要遵守假设，才来调用 GetList 方法。如果值得做很高度的抽象，那么设计 GetList 的作者就会进一步地去判断 typeof(T) 的各个属性上有没有 Attribute 声明，如果有声明就按照声明中的 列名去查找，如果没有则按照属性名。其实这是一个进化的过程。但是只有第一步才最为重要，因为它是开始换了一种思考方法。

Answer 9

对list不熟，你们说的我看了有些头晕。
直接的说是这样的，我在Silverlight项目中要用到list之类的数据集，或者叫非实体集合的数据集。而且还有一点很特别，就是泛型对应的实体类不存在。应该怎么才能给Silverlight返回一个list？
再次说明：List<实体类>   但是实体类不存在

Answer 10

顶顶，Linq确实方便很多的~
[align=center]***********************************************************                    欢迎使用 CSDN 小秘书
             　http://blog.csdn.net/whowhen21***********************************************************[/align]

Answer 11

        /// <summary>
        /// DataTable 转换为List 集合
        /// </summary>
        /// <typeparam name="TResult">类型</typeparam>
        /// <param name="dt">DataTable</param>
        /// <returns></returns>
        public static List<TResult> ToList<TResult>(this DataTable dt) where TResult : class, new()
        {
            //创建一个属性的列表
            List<PropertyInfo> prlist = new List<PropertyInfo>();
            //获取TResult的类型实例  反射的入口
            Type t = typeof(TResult);
            //获得TResult 的所有的Public 属性 并找出TResult属性和DataTable的列名称相同的属性(PropertyInfo) 并加入到属性列表 
            Array.ForEach<PropertyInfo>(t.GetProperties(), p => { if (dt.Columns.IndexOf(p.Name) != -1) prlist.Add(p); });
            //创建返回的集合
            List<TResult> oblist = new List<TResult>();            foreach (DataRow row in dt.Rows)
            {
                //创建TResult的实例
                TResult ob = new TResult();
                //找到对应的数据  并赋值
                prlist.ForEach(p => { if (row[p.Name] != DBNull.Value) p.SetValue(ob, row[p.Name], null); });
                //放入到返回的集合中.
                oblist.Add(ob);
            }
            return oblist;
        }

Answer 12

对了  谁知道这个地址的列子怎么做
http://www.silverlightchina.net/html/tips/2010/1016/2671_2.html

Answer 13

我用的事T-sql，不会linq，
现在做一个项目，在数据库和表名以及列名都不确定的情况下，返回查询的数据集。这在ASP.NET或者C/S模式很容易实现。但是在现有的SL+WCF技术下是不能实现的，首先返回值就不好确定，WCF的返回值类型必须是确定的。比较返回值为Object类型就不可以。而且返回DataTable和DataSet又不可以。在客户接收不到数据，返回的数据类型
你懂的..

Answer 14

不会linq 那就麻烦点 手动写个实体类映射dataset.row 不就可以了

Answer 15

这是在实际项目里用过的。
考虑了数据类型差异引发异常、只读属性被赋值引发异常。
  /// <summary>
    /// 通用数据转换为实体类
    /// </summary>
    public class ModelHelper
    {
        public static T ConvertToModel<T>(DataRow dr) where T : new()
        {
            T t = new T();
            Type modelType = t.GetType();
            foreach (PropertyInfo pi in modelType.GetProperties())
            {
                if (pi == null) continue;
                if (pi.CanWrite == false) continue;                if (dr.Table.Columns.Contains(pi.Name))
                {
                    //p.SetValue(t, GetDefaultValue(dr[p.Name], p.PropertyType), null);
                    try
                    {
                        if (dr[pi.Name] != DBNull.Value)
                            pi.SetValue(t, dr[pi.Name], null);
                        else
                            pi.SetValue(t, default(object), null);
                    }
                    catch
                    {
                        pi.SetValue(t, GetDefaultValue(dr[pi.Name], pi.PropertyType), null);
                    }
                }            }
            return t;
        }
        private static object GetDefaultValue(object obj, Type type)
        {
            if (obj == DBNull.Value)
            {
                return default(object);
            }
            else
            {
                return Convert.ChangeType(obj, type);
            }
        }
        #region DataSet 、 DataTable 转换为实体类泛型集合        /// <summary>
        /// DataSet 第一个表转换为实体类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ds"></param>
        /// <returns>实体类泛型集合</returns>
        public static List<T> ConvertToModel<T>(DataSet ds)
        {
            if (ds.Tables.Count == 0)
                return new List<T>();            return ConvertToModel<T>(ds.Tables[0]);
        }
        /// <summary>
        /// DataTable 第一个表转换为实体类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dt"></param>
        /// <returns>实体类泛型集合</returns>
        public static List<T> ConvertToModel<T>(DataTable dt)
        {
            List<T> l = new List<T>();            foreach (DataRow dr in dt.Rows)
            {
                T model = Activator.CreateInstance<T>();                foreach (DataColumn dc in dr.Table.Columns)
                {
                    PropertyInfo pi = model.GetType().GetProperty(dc.ColumnName);
                    if (pi == null) continue;
                    if (pi.CanWrite == false) continue;                    try
                    {
                        if (dr[dc.ColumnName] != DBNull.Value)
                            pi.SetValue(model, dr[dc.ColumnName], null);
                        else
                            pi.SetValue(model, default(object), null);
                    }
                    catch
                    {
                        pi.SetValue(model, GetDefaultValue(dr[pi.Name], pi.PropertyType), null);
                    }                }
                l.Add(model);
            }            return l;
        }
        #endregion        #region 将实体类转换成DataTable        /// <summary> 
        /// 将实体类转换成DataTable 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="i_objlist"></param> 
        /// <returns></returns> 
        public static DataTable ConvertDataTable<T>(IList<T> objlist)
        {
            if (objlist == null || objlist.Count <= 0)
            {
                return null;
            }
            DataTable dt = new DataTable(typeof(T).Name);
            DataColumn column;
            DataRow row;            System.Reflection.PropertyInfo[] myPropertyInfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);            foreach (T t in objlist)
            {
                if (t == null)
                {
                    continue;
                }                row = dt.NewRow();                for (int i = 0, j = myPropertyInfo.Length; i < j; i++)
                {
                    System.Reflection.PropertyInfo pi = myPropertyInfo[i];                    string name = pi.Name;                    if (dt.Columns[name] == null)
                    {
                        column = new DataColumn(name, pi.PropertyType);
                        dt.Columns.Add(column);
                    }                    row[name] = pi.GetValue(t, null);
                }                dt.Rows.Add(row);
            }
            return dt;
        }
        #endregion
    }

Answer 16

这样肯定无法编译通过，DataRow类型的对象集合无法随意转换为List<T>。

Answer 17

好像WCF 中不能使用List<T>,要通过wcf服务将list传给Silverlight

Answer 18

你们在使用Silverlight的时候是怎么访问数据库的，直接点就是怎么将数据绑定给DataGrid的？

Answer 19

/// <summary>
        /// DataTable 转换为List 集合
        /// </summary>
        /// <typeparam name="TResult">类型</typeparam>
        /// <param name="dt">DataTable</param>
        /// <returns></returns>
        public static List<TResult> ToList<TResult>(this DataTable dt) where TResult : class, new()
        {
            //创建一个属性的列表
            List<PropertyInfo> prlist = new List<PropertyInfo>();
            //获取TResult的类型实例  反射的入口
            Type t = typeof(TResult);
            //获得TResult 的所有的Public 属性 并找出TResult属性和DataTable的列名称相同的属性(PropertyInfo) 并加入到属性列表 
            Array.ForEach<PropertyInfo>(t.GetProperties(), p => { if (dt.Columns.IndexOf(p.Name) != -1) prlist.Add(p); });
            //创建返回的集合
            List<TResult> oblist = new List<TResult>();            foreach (DataRow row in dt.Rows)
            {
                //创建TResult的实例
                TResult ob = new TResult();
                //找到对应的数据  并赋值
                prlist.ForEach(p => { if (row[p.Name] != DBNull.Value) p.SetValue(ob, row[p.Name], null); });
                //放入到返回的集合中.
                oblist.Add(ob);
            }
            return oblist;
        }

Answer 20

判断中改为这样可避免为空的数据而引起的错误   
    if (table.Columns.Contains(tempName) && row[tempName] != DBNull.Value)