zoukankan      html  css  js  c++  java
  • 对象列表转换为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()[0];
                        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 <= 0) return null;
                    Type type = list[0].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 = 0;
                    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 += 1;
                    }
                    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) >= 0)
                {
                    object value = row[propertyName];
                    if (value != null && value is DateTime)
                    {
                        if ((DateTime)value <= DateTime.MinValue.AddDays(1))
                            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) >= 0)
                        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) >= 0)
                        row[info.Name] = info.GetValue(o, null);
                }
                dt.Rows.Add(row);
                return row;
            }
    
            public static void SetTwoRowValues(DataRow rowFrom, DataRow rowTo)
            {
                for (int i = 0; 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 = 0; 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) >= 0)
                        {
                            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 = 0; 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 == 0) continue;
                    HQL += "'" + str + "',";
                }
                if (HQL.Substring(HQL.Length - 1, 1) == ",")
                    HQL = HQL.Substring(0, HQL.Length - 1);
                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 == 0) continue;
                    HQL += "''" + str + "'',";
                }
                if (HQL.Substring(HQL.Length - 1, 1) == ",")
                    HQL = HQL.Substring(0, HQL.Length - 1);
                return HQL;
            }
    
    
            public static string ToSQLInDataFormat(string[] input)
            {
                string HQL = string.Empty;
                if (input.Length == 0)
                    return HQL;
    
                foreach (string str in input)
                {
                    HQL += "'" + str + "',";
                }
                if (HQL.Substring(HQL.Length - 1, 1) == ",")
                    HQL = HQL.Substring(0, HQL.Length - 1);
                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 = 0; 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) < 0)
                        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 > 0)
                {
                    if (str[0] == ',')
                        str = str.Substring(1, str.Length - 1);
                    if (str[str.Length - 1] == ',')
                        str = str.Substring(0, str.Length - 1);
                }
                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 = 0; i < dr.Table.Columns.Count; i++)
                {
                    string colname = dr.Table.Columns[i].ColumnName;
                    if (dt.Columns.IndexOf(colname) >= 0)
                    {
                        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(), 1);
            }
    
            /// <summary>
            /// 返回一个半角 去左右空格 大写的字符串
            /// </summary>
            public static string ToTUBS(object o)
            {
                return BigToSmall(o.ToString().Trim().ToUpper(), 1);
            }
    
            /// <summary>
            /// 判断字符是否是数字。是返回true 
            /// </summary>
            /// <param name="c"></param>
            /// <returns></returns>
            public static bool NuNumber(char c)
            {
                if ((int)c >= 48 && (int)c <= 57)
                    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 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 '﹃﹄『』$/abcdefghijklmnopqrstuvwxyz.*";
                to_strBig = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 '“”“”$/abcdefghijklmnopqrstuvwxyz.*";
                int i;
                for (i = 0; i < strBig.Length; i++)
                {
                    if (direction != -1)
                    {
                        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 = 0; 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 = 0;
                    int iEnd = text.Length - 1;
                    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 = 0; i < ret.Length; i++)
                    {
                        ret[i] = Convert.ToInt32(list[i]);
                    }
                }
                catch
                {
                    ret = null;
                }
                return ret;
            }
    
    
        }
    
    }
    jin 2011-2014
  • 相关阅读:
    常见RGB透明度对照表在这
    Android节假日图标动态替换方案
    用两个栈实现队列
    从头到尾打印链表 (链表/栈)
    MySQL常用函数
    找出数组中重复的数字
    两数之和
    java的list的几种排序写法整理(sort的用法)
    Java知识目录
    通过关键词来推荐话题
  • 原文地址:https://www.cnblogs.com/hongtian/p/3596572.html
Copyright © 2011-2022 走看看