对象列表转换为DataTable或DataTable转换为对象列表.

/**********************************************************************************/
//  说明: 数据转换工具.
//  注意: 对象列表转换为DataTable或DataTable转换为对象列表.
//        字段参照由对象的PropertyName决定.
//        数据模型类的属性名必需与字段名一致, 包括大小写一致.
/**********************************************************************************/

using System;
using System.Reflection;
using System.Collections;
using System.Data;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Xml;
using System.Web.UI;

namespace vjsdn.converter
{
    public class CDataConvert
    {

        /// <summary>
        /// 根据类创建表结构
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public static DataTable CreateTable(Type t)
        {
            return BuiltTable(t.GetProperties());
        }

        /// <summary>
        /// 根据对象的属性创建数据表
        /// </summary>
        private static DataTable BuiltTable(PropertyInfo[] pinfo)
        {
            try
            {
                if (pinfo == null) return null;
                DataTable table = new DataTable();
                foreach (PropertyInfo info in pinfo)
                {
                    Type type = info.PropertyType;
                    if (info.PropertyType.IsGenericType)
                        type = info.PropertyType.GetGenericArguments()[];
                    DataColumn column = new DataColumn(info.Name, type);
                    column.AllowDBNull = true;
                    table.Columns.Add(column);
                }
                return table;
            }
            catch { return null; }
        }

        /// <summary>
        /// Object to Object. 将一个对象转换为指定类型的对象.
        /// 注意: destination内的Property必需在source内存在.
        /// </summary>
        public static object CopyProperties(object source, Type destination)
        {
            try
            {
                if (source == null) return null;
                object destObj = destination.Assembly.CreateInstance(destination.FullName);
                PropertyInfo[] propsDest = destObj.GetType().GetProperties();
                foreach (PropertyInfo infoDest in propsDest)
                {
                    object value = GetValueOfObject(source, infoDest.Name);
                    if (CanShallowCopyProperty(value)) SetPropertyValue(destObj, infoDest, value);
                }
                return destObj;
            }
            catch { return null; }
        }

        /// <summary>
        /// 指定参数是否可用于浅拷贝
        /// </summary>
        private static bool CanShallowCopyProperty(object propValue)
        {
            if (propValue == null) return true;
            if (propValue.GetType().IsValueType || propValue is string) return true;
            return false;
        }

        /// <summary>
        /// 复制对象属性.
        /// </summary>
        public static void CopyProperties(object source, object destObj)
        {
            try
            {
                if (source == null || destObj == null) return;
                PropertyInfo[] propsDest = destObj.GetType().GetProperties();
                foreach (PropertyInfo infoDest in propsDest)
                {
                    object value = GetValueOfObject(source, infoDest.Name);
                    if (CanShallowCopyProperty(value)) SetPropertyValue(destObj, infoDest, value);
                }
            }
            catch { }
        }

        /// <summary>
        /// 复制对象. 浅拷贝.
        /// </summary>
        public static object CloneObject(object source)
        {
            try
            {
                if (source == null) return null;
                Type objType = source.GetType();
                object destObj = objType.Assembly.CreateInstance(objType.FullName);
                PropertyInfo[] propsSource = objType.GetProperties();
                foreach (PropertyInfo infoSource in propsSource)
                {
                    object value = GetValueOfObject(source, infoSource.Name);
                    if (CanShallowCopyProperty(value)) SetPropertyValue(destObj, infoSource, value);
                }
                return destObj;
            }
            catch { return null; }
        }

        /// <summary>
        /// 复制一个对象数组.
        /// </summary>
        public static ArrayList CloneObjects(IList source)
        {
            if (source == null) return null;
            ArrayList ret = new ArrayList();
            foreach (object o in source) ret.Add(CloneObject(o));
            return ret;
        }

        /// <summary>
        /// 获取对象指定属性的值
        /// </summary>
        public static object GetValueOfObject(object obj, string property)
        {
            try
            {
                if (obj == null) return null;
                Type type = obj.GetType();
                PropertyInfo[] pinfo = type.GetProperties();
                foreach (PropertyInfo info in pinfo)
                {
                    if (info.Name.ToUpper() == property.ToUpper())
                        return info.GetValue(obj, null);
                }
                return null;
            }
            catch { return null; }
        }

        /// <summary>
        /// 纵对象数据组取出某一个对象. 返回对象指定属性名称(returnPropName)的值
        /// </summary>
        public static object GetObjectValueByKey(IList objects, string keyPropName, object keyValue, string returnPropName)
        {
            object o = GetObjectByKey(objects, keyPropName, keyValue);
            if (o != null)
                return GetValueOfObject(o, returnPropName);
            else
                return null;
        }

        /// <summary>
        /// 纵对象数据组取出某一个对象. 参数指定关键字段名称(keyPropName)及值(keyValue).
        /// </summary>
        public static object GetObjectByKey(IList objects, string keyPropName, object keyValue)
        {
            foreach (object o in objects)
            {
                object value = GetValueOfObject(o, keyPropName);
                if (value == null) continue;
                if (value.ToString().ToLower() == keyValue.ToString().ToLower())
                {
                    return o;
                }
            }
            return null;
        }

        /// <summary>
        /// 查找对象包含指定属性.
        /// </summary>
        public static bool FindProperty(object obj, string property)
        {
            try
            {
                if (obj == null) return false;
                Type type = obj.GetType();
                PropertyInfo[] pinfo = type.GetProperties();
                foreach (PropertyInfo info in pinfo)
                {
                    if (info.Name.ToUpper() == property.ToUpper())
                        return true;
                }
                return false;
            }
            catch { return false; }
        }

        public static void SetValueofDataRow(DataRow dr, string field, object value)
        {
            try
            {
                if (dr == null) return;
                dr[field] = value;

            }
            catch
            {

            }
        }

        /// <summary>
        /// 设置对象某个属性的值
        /// </summary>
        public static void SetValueOfObject(object obj, string property, object value)
        {
            try
            {
                if (obj == null) return;
                Type type = obj.GetType();
                PropertyInfo[] pinfo = type.GetProperties();
                foreach (PropertyInfo info in pinfo)
                {
                    if (info.Name.ToUpper() == property.ToUpper())
                    {
                        SetPropertyValue(obj, info, value);
                        break;
                    }
                }
            }
            catch { }
        }

        public static void SetPropertyValue(object instance, PropertyInfo prop, object value)
        {
            try
            {
                if (prop == null) return;
                if (prop.PropertyType.ToString() == "System.String")
                { }
                else if (prop.PropertyType.ToString() == "System.Decimal")
                    value = Decimal.Parse(value.ToString());
                else if (prop.PropertyType.ToString() == "System.Int32")
                    value = int.Parse(value.ToString());
                else if (prop.PropertyType.ToString() == "System.Single")
                    value = Single.Parse(value.ToString());
                else if (prop.PropertyType.ToString() == "System.DateTime")
                    value = DateTime.Parse(value.ToString());
                prop.SetValue(instance, value, null);
            }
            catch { }
        }

        public static IList CSharpDataTypes()
        {
            ArrayList list = new ArrayList();
            list.Add(typeof(System.DateTime));
            list.Add(typeof(System.Byte));
            list.Add(typeof(System.SByte));
            list.Add(typeof(System.Int16));
            list.Add(typeof(System.Int32));
            list.Add(typeof(System.Int64));
            list.Add(typeof(System.IntPtr));
            list.Add(typeof(System.UInt16));
            list.Add(typeof(System.UInt32));
            list.Add(typeof(System.UInt64));
            list.Add(typeof(System.UIntPtr));
            list.Add(typeof(System.Single));
            list.Add(typeof(System.Double));
            list.Add(typeof(System.Decimal));
            list.Add(typeof(System.Boolean));
            list.Add(typeof(System.Char));
            list.Add(typeof(System.String));
            return list;
        }

        /// <summary>
        /// 根据IList对象创建数据表
        /// </summary>
        public static DataTable IListToDataTable(IList list)
        {
            try
            {
                if (list == null) return null;
                if (list.Count <= ) return null;
                Type type = list[].GetType();
                PropertyInfo[] pinfo = type.GetProperties();

                DataTable table = BuiltTable(pinfo);//创建表
                DataRow row = null;
                foreach (object o in list)
                {
                    row = table.NewRow();
                    foreach (PropertyInfo info in pinfo)
                    {
                        object v = info.GetValue(o, null);
                        if (!ColumnExists(table, info.Name)) continue;
                        if (null == v)
                            row[info.Name] = DBNull.Value;
                        else
                            row[info.Name] = v;
                    }
                    table.Rows.Add(row);
                }
                return table;
            }
            catch { return null; }
        }

        public static bool ColumnExists(DataTable dt, string columnName)
        {
            if (dt == null) return false;
            foreach (DataColumn col in dt.Columns)
            {
                if (col.ColumnName.ToLower() == columnName.ToLower())
                    return true;
            }
            return false;
        }

        /// <summary>
        /// 数据表转换为IList对象,Type参数:对象类型
        /// </summary>
        public static IList DataTableToIList(DataTable table, Type type)
        {
            try
            {
                if (table == null) return null;
                IList list = new object[table.Rows.Count];
                object o = null;
                PropertyInfo[] pinfo = type.GetProperties();
                int idx = ;
                foreach (DataRow row in table.Rows)
                {
                    o = type.Assembly.CreateInstance(type.FullName);
                    foreach (PropertyInfo info in pinfo)
                    {
                        SetPropertyValue(o, info, GetFieldValue(row, info.Name));
                    }
                    list[idx] = o;
                    idx += ;
                }
                return list;
            }
            catch { return null; }
        }

        /// <summary>
        /// 根据对象的属性取字段的值
        /// </summary>
        private static object GetFieldValue(DataRow row, string propertyName)
        {
            if (row == null) return null;
            if (row.Table.Columns.IndexOf(propertyName) >= )
            {
                object value = row[propertyName];
                if (value != null && value is DateTime)
                {
                    if ((DateTime)value <= DateTime.MinValue.AddDays())
                        value = null;
                }
                return value;
            }
            return null;
        }

        public static DataRow UpdateDataRowFromObject(DataRow row, object o)
        {
            PropertyInfo[] pinfo = o.GetType().GetProperties();
            foreach (PropertyInfo info in pinfo)
            {
                if (row.Table.Columns.IndexOf(info.Name) >= )
                    row[info.Name] = info.GetValue(o, null);
            }
            return row;
        }

        public static DataRow AddDataRowFromObject(DataTable dt, object o)
        {
            DataRow row = dt.NewRow();
            PropertyInfo[] pinfo = o.GetType().GetProperties();
            foreach (PropertyInfo info in pinfo)
            {
                if (dt.Columns.IndexOf(info.Name) >= )
                    row[info.Name] = info.GetValue(o, null);
            }
            dt.Rows.Add(row);
            return row;
        }

        public static void SetTwoRowValues(DataRow rowFrom, DataRow rowTo)
        {
            for (int i = ; i < rowFrom.Table.Columns.Count; i++)
            {
                rowTo[i] = rowFrom[i];
            }
        }

        /// <summary>
        /// 从源行中对相同字段名的列付值
        /// </summary>
        /// <param name="drSouce"></param>
        /// <param name="drTo"></param>
        public static void SetTwoRowSameColValue(DataRow drSource, DataRow drTo)
        {
            for (int i = ; i < drSource.Table.Columns.Count; i++)
            {
                string fieldname = drSource.Table.Columns[i].ColumnName;
                DataColumn col = drTo.Table.Columns[fieldname];
                if (col != null)
                {
                    drTo[fieldname] = drSource[fieldname];
                }
            }

        }

        /// <summary>
        /// 数据行(DataRow)转换为对象,对象的Type由type参数决定.
        /// </summary>
        public static object DataRowToObject(DataRow row, Type type)
        {
            if (null == row) return null;
            try
            {
                object o = type.Assembly.CreateInstance(type.FullName);
                PropertyInfo[] pinfo = type.GetProperties();
                foreach (PropertyInfo info in pinfo)
                {
                    //字段名称与对象属性相符才赋值
                    if (row.Table.Columns.IndexOf(info.Name) >= )
                    {
                        object v = GetFieldValue(row, info.Name);
                        SetPropertyValue(o, info, v);
                    }
                }
                return o;
            }
            catch { return null; }
        }

        /// <summary>
        /// ArrayList转换为对象数组.
        /// </summary>
        public static object[] ToObjects(IList source)
        {
            if (null == source) return null;
            object[] ret = new object[source.Count];
            for (int i = ; i < source.Count; i++) ret[i] = source[i];
            return ret;
        }

        /// <summary>
        /// 对象数组转换为ArrayList.
        /// </summary>
        public static ArrayList ToArrayList(IList list)
        {
            if (list == null) return null;
            ArrayList arrlist = new ArrayList();
            foreach (object o in list) arrlist.Add(o);
            return arrlist;
        }

        /// <summary>
        /// 对象数组转换为ArrayList.
        /// </summary>
        public static ArrayList ToArrayList(object[] source)
        {
            if (null != source)
                return new ArrayList((ICollection)source);
            else //如果来源数据为null,返回一个空的ArrayList.
                return new ArrayList();
        }

        /// <summary>
        /// 把字符串以逗号分格，转换成数据库格式in('a','b')
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToSQLInDataFormat(string input)
        {
            string HQL = string.Empty;
            if (input == string.Empty)
                return HQL;

            string[] sArray = input.Split(',');
            foreach (string str in sArray)
            {
                if (str.Length == ) continue;
                HQL += "'" + str + "',";
            }
            if (HQL.Substring(HQL.Length - , ) == ",")
                HQL = HQL.Substring(, HQL.Length - );
            return HQL;

        }

        /// <summary>
        /// 把字符串以逗号分格，转换成数据库格式''a'',''b''
        /// </summary>
        public static string ToSQLInDataFormatTwo(string input)
        {
            string HQL = string.Empty;
            if (input == string.Empty)
                return HQL;

            string[] sArray = input.Split(',');
            foreach (string str in sArray)
            {
                if (str.Length == ) continue;
                HQL += "''" + str + "'',";
            }
            if (HQL.Substring(HQL.Length - , ) == ",")
                HQL = HQL.Substring(, HQL.Length - );
            return HQL;
        }

        public static string ToSQLInDataFormat(string[] input)
        {
            string HQL = string.Empty;
            if (input.Length == )
                return HQL;

            foreach (string str in input)
            {
                HQL += "'" + str + "',";
            }
            if (HQL.Substring(HQL.Length - , ) == ",")
                HQL = HQL.Substring(, HQL.Length - );
            return HQL;

        }

        /// <summary>
        /// 从table转成dataset
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static DataSet TableToDataSet(DataTable dt)
        {
            DataSet ds = new DataSet();
            ds.Tables.Add(dt);
            return ds;
        }

        public static DataSet TableToDataSet(DataTable[] dtArr)
        {
            DataSet ds = new DataSet();
            for (int i = ; i < dtArr.Length; i++)
            {
                ds.Tables.Add(dtArr[i]);
            }
            return ds;
        }

        /// <summary>
        /// 修改对表的某列的值
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="value"></param>
        public static bool UpdateTableCol(DataTable dt, string fieldName, object value)
        {
            try
            {
                if (dt.Columns.IndexOf(fieldName) < )
                    throw new Exception("表没有" + fieldName + "列！");

                foreach (DataRow dr in dt.Rows)
                {
                    dr[fieldName] = value;
                }

                return true;
            }
            catch
            {
                return false;
            }

        }

        /// <summary>
        /// 以逗号分格字符串，返回数组
        /// 如果第一个和最后一个字符为, 去掉
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string[] ToStringSplit(string str)
        {
            if (str.Length > )
            {
                if (str[] == ',')
                    str = str.Substring(, str.Length - );
                if (str[str.Length - ] == ',')
                    str = str.Substring(, str.Length - );
            }
            string[] sArray = str.Split(',');
            return sArray;
        }

        /// <summary>
        /// 把一个行的数据新增一个表中
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="dr"></param>
        /// <returns></returns>
        public static DataTable AddTableRowByRow(DataTable dt, DataRow dr)
        {

            bool b = false;
            DataRow drNew = dt.NewRow();
            for (int i = ; i < dr.Table.Columns.Count; i++)
            {
                string colname = dr.Table.Columns[i].ColumnName;
                if (dt.Columns.IndexOf(colname) >= )
                {
                    drNew[colname] = dr[colname];
                    b = true;
                }
            }

            if (b)
                dt.Rows.Add(drNew);
            return dt;
        }

    }

    /// <summary>
    /// 对字符或字符串的处理
    /// </summary>
    public class DOString
    {
        /// <summary>
        /// 把字符转成大写并去两边空格
        /// </summary>
        public static string ToTrimAndUpper(string str)
        {
            return str.Trim().ToUpper();
        }

        public static string ToTrimAndUpper(object o)
        {
            return o.ToString().Trim().ToUpper();
        }

        public static string ToTrimAndBigToSmall(object o)
        {
            return BigToSmall(o.ToString().Trim(), );
        }

        /// <summary>
        /// 返回一个半角 去左右空格 大写的字符串
        /// </summary>
        public static string ToTUBS(object o)
        {
            return BigToSmall(o.ToString().Trim().ToUpper(), );
        }

        /// <summary>
        /// 判断字符是否是数字。是返回true
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        public static bool NuNumber(char c)
        {
            if ((int)c >=  && (int)c <= )
                return true;
            else
                return false;

        }

        /// <summary>
        /// 去除千分号
        /// </summary>
        public static object OffkiloSign(object obj)
        {
            if (obj == null)
                return obj;
            string s = obj.ToString();
            return s.Replace(",", string.Empty);
        }

        /// <summary>
        /// 全角半角间转换 direction =-1 (半角转全角)
        /// </summary>

        public static string BigToSmall(string content, int direction)
        {
            string strBig, to_strBig;
            strBig = "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９　＇﹃﹄『』＄／ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ．＊";
            to_strBig = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 '“”“”$/abcdefghijklmnopqrstuvwxyz.*";
            int i;
            for (i = ; i < strBig.Length; i++)
            {
                if (direction != -)
                {
                    content = content.Replace(strBig[i], to_strBig[i]);
                }
                else
                {
                    content = content.Replace(to_strBig[i], strBig[i]);
                }
            }
            return content;
        }

        /// <summary>
        /// 对比两个字符串的ASCII值大小，要是X1>X2,将X1,X2交换
        /// </summary>
        public static void CompareStringASCII(ref string x1, ref string x2)
        {
            if (string.IsNullOrEmpty(x1) || string.IsNullOrEmpty(x2))
                return;
            string y1 = x1.ToUpper();
            string y2 = x2.ToUpper();
            int iLength = y1.Length;
            if (y2.Length < iLength)
                iLength = y2.Length;
            for (int i = ; i < iLength; i++)
            {
                int iASC1 = (int)y1[i];
                int iASC2 = (int)y2[i];
                if (iASC1 > iASC2)
                {
                    string tmp = x1;
                    x1 = x2;
                    x2 = tmp;
                    break;
                }

                if (iASC1 < iASC2)
                    break;

            }
        }

        /// <summary>
        /// 查找出text中含有spilt字符串从第几个字符结束的位置数组
        /// </summary>
        /// <param name="text">"12345678901234567890"</param>
        /// <param name="spilt">"12"</param>
        /// <returns>2，13</returns>
        public static int[] DoStringIndexArray(string text, string spilt)
        {
            int[] ret = null;
            try
            {
                int iStart = ;
                int iEnd = text.Length - ;
                int spiltLength = spilt.Length;
                ArrayList list = new ArrayList();
                while (iStart <= iEnd)
                {
                    int index = text.IndexOf(spilt, iStart);
                    iStart = index + spiltLength;
                    if (iStart <= iEnd)
                    {
                        list.Add(iStart);
                    }
                }
                ret = new int[list.Count];
                for (int i = ; i < ret.Length; i++)
                {
                    ret[i] = Convert.ToInt32(list[i]);
                }
            }
            catch
            {
                ret = null;
            }
            return ret;
        }

    }

}