using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;

namespace DataCommon
{
    public class DatatableToEntity
    {
        public class ConvertHelper<T> where T : class, new()
        {
            /// <summary>  
            /// 利用反射和泛型  
            /// </summary>  
            /// <param name="dt"></param>  
            /// <returns></returns>  
            public static List<T> ConvertToList(DataTable dt)
            {
                // 定义集合  
                List<T> ts = new List<T>();
                try
                {
                    // 获得此模型的类型  
                    Type type = typeof(T);
                    //定义一个临时变量  
                    string tempName = string.Empty;
                    ///列的属性Status是否改变 
                    bool typeChange = false;
                    DataTable resutTable = dt.Clone();
                    foreach (DataColumn clmn in resutTable.Columns)
                    {
                        PropertyInfo[] propertys = type.GetProperties();
                        //遍历该对象的所有属性  
                        foreach (PropertyInfo pi in propertys)
                        {
                            if (pi.Name.ToUpper() == clmn.ColumnName.ToUpper())
                            {
                                if (pi.PropertyType != clmn.DataType)
                                {
                                    clmn.DataType = pi.PropertyType;
                                    typeChange = true;
                                    continue;

                                }
                            }
                        }
                    }
                    if (typeChange)
                    {
                        foreach (DataRow dr in dt.Rows)
                        {
                            DataRow row = resutTable.NewRow();
                            try
                            {
                                foreach (DataColumn clm in dt.Columns)
                                {
                                    row[clm.ColumnName] = dr[clm.ColumnName];
                                }

                            }
                            catch (Exception ex)
                            {

                            }
                            resutTable.Rows.Add(row);
                            resutTable.AcceptChanges();
                        }

                    }
                    else
                    {
                        resutTable = dt.Copy();
                    }
                    //遍历DataTable中所有的数据行  
                    foreach (DataRow dr in resutTable.Rows)
                    {
                        T t = new T();
                        // 获得此模型的公共属性  
                        PropertyInfo[] propertys = t.GetType().GetProperties();
                        //遍历该对象的所有属性  
                        foreach (PropertyInfo pi in propertys)
                        {
                            tempName = pi.Name;//将属性名称赋值给临时变量  
                                               //检查DataTable是否包含此列（列名==对象的属性名）    
                            if (dt.Columns.Contains(tempName))
                            {
                                Type v = pi.PropertyType;

                                // 判断此属性是否有Setter  
                                if (!pi.CanWrite) continue;//该属性不可写，直接跳出  
                                                           //取值  
                                object value = dr[tempName];
                                if (v != dr[tempName].GetType())
                                {

                                }
                                //如果非空，则赋给对象的属性  
                                if (value != DBNull.Value)

                                    pi.SetValue(t, value, null);
                            }
                        }
                        //对象添加到泛型集合中  
                        ts.Add(t);
                    }
                }
                catch (Exception ex)
                {

                }

                return ts;

            }

            /// <summary>
            /// 将集合类转换成DataTable
            /// </summary>
            /// <param name="list">集合</param>
            /// <returns></returns>
            public static DataTable ToDataTable(IList<T> list)
            {
                DataTable result = new DataTable();
                if (list.Count > 0)
                {
                    PropertyInfo[] propertys = list[0].GetType().GetProperties();
                    foreach (PropertyInfo pi in propertys)
                    {
                        result.Columns.Add(pi.Name, pi.PropertyType);
                    }

                    for (int i = 0; i < list.Count; i++)
                    {
                        ArrayList tempList = new ArrayList();
                        foreach (PropertyInfo pi in propertys)
                        {
                            object obj = pi.GetValue(list[i], null);
                            tempList.Add(obj);
                        }
                        object[] array = tempList.ToArray();
                        result.LoadDataRow(array, true);
                    }
                }
                return result;
            }
        }
    }
}