C#資料實體轉換類EntityHelper

/// <summary>
    /// 資料實體轉換類
    /// </summary>
    public class EntityHelper
    {

        /// <summary>
        /// 判斷DataSet預設表是否為空:true:不為空 false:為空。
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        public static bool CheckDataSet(DataSet ds)
        {
            bool isNull = CheckDataSet(ds, 0);
            return isNull;
        }

        /// <summary>
        /// 判斷DataSet指定索引表是否為空:true:不為空 false:為空。
        /// </summary>
        /// <param name="ds">DataSet</param>
        /// <param name="tableIndex">表的索引值</param>
        /// <returns></returns>
        public static bool CheckDataSet(DataSet ds, int tableIndex)
        {
            bool isNull = false;
            if (ds != null && ds.Tables != null && ds.Tables.Count > tableIndex && ds.Tables[tableIndex] != null && ds.Tables[tableIndex].Rows != null && ds.Tables[tableIndex].Rows.Count > 0)
            {
                isNull = true;
            }
            return isNull;
        }



        /// <summary>
        /// 根據資料表生成相應的實體對象清單
        /// </summary>
        /// <typeparam name="T">實體類型</typeparam>
        /// <param name="srcDT">資料</param>
        /// <param name="relation">資料庫表列名與對象屬性名對應關系；如果列名與實體對象屬性名相同，該參數可為空</param>
        /// <returns>對象清單</returns>
        public static List<T> GetEntityListByDT<T>(DataTable srcDT, Hashtable relation)
        {
            List<T> list = null;
            T destObj = default(T);

            if (srcDT != null && srcDT.Rows.Count > 0)
            {

                list = new List<T>();
                foreach (DataRow row in srcDT.Rows)
                {
                    destObj = GetEntityListByDT<T>(row, relation);
                    list.Add(destObj);
                }
            }

            return list;
        }

        /// <summary>
        ///  将SqlDataReader轉換成資料實體 add by trenhui
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row"></param>
        /// <param name="relation"></param>
        /// <returns></returns>
        public static T GetEntityListByDT<T>(SqlDataReader dr)
        {
            Type type = typeof(T);
            T destObj = Activator.CreateInstance<T>();
            foreach (PropertyInfo prop in type.GetProperties())
            {
                try
                {
                    if (dr[prop.Name] != null && dr[prop.Name] != DBNull.Value)
                    {
                        SetPropertyValue(prop, destObj, dr[prop.Name]);
                    }
                }
                catch { }
            }
            return destObj;
        }

        /// <summary>
        ///  将資料行轉換成資料實體
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ds"></param>
        /// <returns></returns>
        public static T GetEntityListByDT<T>(DataSet ds)
        {
            Type type = typeof(T);
            T destObj = Activator.CreateInstance<T>();

            try
            {
                DataRow row = ds.Tables[0].Rows[0];
                foreach (PropertyInfo prop in type.GetProperties())
                {
                    if (row.Table.Columns.Contains(prop.Name) &&
                        row[prop.Name] != DBNull.Value)
                    {
                        SetPropertyValue(prop, destObj, row[prop.Name]);
                    }
                }
            }
            catch (Exception ex)
            {

            }

            return destObj;
        }

        /// <summary>
        ///  将資料行轉換成資料實體
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row">單行Datarow</param>
        /// <param name="relation">需要實體轉換的Hashtable 可為null</param>
        /// <returns>傳回一個泛型</returns>
        public static T GetEntityListByDT<T>(DataRow row, Hashtable relation)
        {
            Type type = typeof(T);
            T destObj = Activator.CreateInstance<T>();
            PropertyInfo temp = null;
            foreach (PropertyInfo prop in type.GetProperties())
            {
                if (row.Table.Columns.Contains(prop.Name) &&
                    row[prop.Name] != DBNull.Value)
                {
                    SetPropertyValue(prop, destObj, row[prop.Name]);
                }
            }

            if (relation != null)
            {

                foreach (string name in relation.Keys)
                {
                    temp = type.GetProperty(relation[name].ToString());
                    if (temp != null &&
                        row[name] != DBNull.Value)
                    {
                        SetPropertyValue(temp, destObj, row[name]);
                    }
                }
            }

            return destObj;
        }

        /// <summary>
        ///  将多資料行轉換成資料實體清單
        /// </summary>
        /// <typeparam name="T">泛型</typeparam>
        /// <param name="row">行數組</param>
        /// <param name="relation">需要實體轉換的Hashtable 可為null</param>
        /// <returns>傳回List泛型數組</returns>
        public static List<T> GetEntityListByDT<T>(DataRow[] rows, Hashtable relation)
        {
            List<T> list = null;
            T destObj = default(T);

            if (rows != null && rows.Length > 0)
            {

                list = new List<T>();
                foreach (DataRow row in rows)
                {
                    destObj = GetEntityListByDT<T>(row, relation);
                    list.Add(destObj);
                }
            }

            return list;
        }

        /// <summary>
        /// 為對象的屬性指派
        /// </summary>
        /// <param name="prop">屬性</param>
        /// <param name="destObj">目标對象</param>
        /// <param name="value">源值</param>
        private static void SetPropertyValue(PropertyInfo prop, object destObj, object value)
        {
            object temp = ChangeType(prop.PropertyType, value);
            prop.SetValue(destObj, temp, null);
        }

        /// <summary>
        /// 用于類型資料的指派
        /// </summary>
        /// <param name="type">目标類型</param>
        /// <param name="value">原值</param>
        /// <returns></returns>
        private static object ChangeType(Type type, object value)
        {
            int temp = 0;
            if ((value == null) && type.IsGenericType)
            {
                return Activator.CreateInstance(type);
            }
            if (value == null)
            {
                return null;
            }
            if (type == value.GetType())
            {
                return value;
            }
            if (type.IsEnum)
            {
                if (value is string)
                {
                    return Enum.Parse(type, value as string);
                }
                return Enum.ToObject(type, value);
            }

            if (type == typeof(bool) && typeof(int).IsInstanceOfType(value))
            {
                temp = int.Parse(value.ToString());
                return temp != 0;
            }
            if (!type.IsInterface && type.IsGenericType)
            {
                Type type1 = type.GetGenericArguments()[0];
                object obj1 = ChangeType(type1, value);
                return Activator.CreateInstance(type, new object[] { obj1 });
            }
            if ((value is string) && (type == typeof(Guid)))
            {
                return new Guid(value as string);
            }
            if ((value is string) && (type == typeof(Version)))
            {
                return new Version(value as string);
            }
            if (!(value is IConvertible))
            {
                return value;
            }
            return Convert.ChangeType(value, type);
        }
    }
           

此類蠻實用的！三層開發或者多層開發基本讀取資料不需要在進行指派！直接進行調用方法直接指派給實體等！大大節省開發時間