/**********************************************************************************/
// 说明: 数据转换工具.
// 注意: 对象列表转换为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;
} } }