【C#公共帮助类】 Convert帮助类

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

namespace Common
{
public partial class DataTable
{
/// <summary>
/// 转换 DataTable 对象为 IList 对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <returns>数组对象</returns>
public static T[] ToArray<T>(DataTable datas) where T : class, new()
{
List<T> list = ToList<T>(datas) as List<T>;
return list.ToArray();
}

/// <summary>
/// 转换IList对象为DataTable对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <returns>DataTable对象</returns>
public static DataTable ToDataTable<T>(IList<T> datas)
{
return ToDataTable<T>(datas, null);
}

/// <summary>
/// 转换IList对象为DataTable对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <returns>DataTable对象</returns>
public static DataTable ToDataTable<T>(T[] datas)
{
return ToDataTable<T>(datas, null);
}

/// <summary>
/// 转换IList对象为DataTable对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <param name="tableName">要创建的表名</param>
/// <returns>DataTable对象</returns>
public static DataTable ToDataTable<T>(IList<T> datas, string tableName)
{
Type type = typeof(T);
if (string.IsNullOrEmpty(tableName))
{
tableName = type.Name;
}
DataTable table = new DataTable(tableName);
table.BeginLoadData();
PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo info in properties)
{
string typeName = info.PropertyType.ToString();
if (info.PropertyType.IsGenericType)
{
typeName = info.PropertyType.GetGenericArguments()[0].ToString();
}
Type type2 = Type.GetType(typeName, false);
if (type2 != null)
{
table.Columns.Add(info.Name, type2);
}
}
if ((datas != null) && (datas.Count > 0))
{
foreach (object obj2 in datas)
{
DataRow row = table.NewRow();
foreach (PropertyInfo info2 in properties)
{
if ((Type.GetType(info2.PropertyType.ToString(), false) != null) && (info2.GetValue(obj2, null) != null))
{
row[info2.Name] = info2.GetValue(obj2, null);
}
}
table.Rows.Add(row);
}
}
table.EndLoadData();
table.AcceptChanges();
return table;
}

public static DataTable ListToDataTable(object datas, string tableName)
{
Type type = ZGeneric.GetGenericType(datas);
if (string.IsNullOrEmpty(tableName))
tableName = type.Name;

DataTable table = new DataTable(tableName);
table.BeginLoadData();

var properties = ZReflection.GetProperties(type);
foreach (var p in properties)
{
Type colType = p.Value.PropertyType;
string typeName = colType.ToString();
if (colType.IsGenericType)
typeName = colType.GetGenericArguments()[0].ToString();

Type newType = Type.GetType(typeName, false);
if (newType != null)
table.Columns.Add(p.Value.Name, newType);
}

IEnumerator enumerator = ((dynamic)datas).GetEnumerator();
while (enumerator.MoveNext())
{
DataRow row = table.NewRow();
foreach (var p in properties)
{
var value = ZGeneric.GetValue(enumerator.Current, p.Value.Name);
if ((Type.GetType(p.Value.PropertyType.ToString(), false) != null) && (value != null))
row[p.Value.Name] = value;
}
table.Rows.Add(row);
}
table.EndLoadData();
table.AcceptChanges();
return table;
}

/// <summary>
/// 转换IList对象为DataTable对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <param name="tableName">要创建的表名</param>
/// <returns>DataTable对象</returns>
public static DataTable ToDataTable<T>(T[] datas, string tableName)
{
IList<T> list;
if ((datas == null) || (datas.Length == 0))
{
list = new List<T>();
}
else
{
list = new List<T>(datas);
}
return ToDataTable<T>(list, tableName);
}

/// <summary>
/// 转换 DataTable 对象为 IList 对象
/// </summary>
/// <param name="datas">数据集合</param>
/// <returns>IList 对象</returns>
public static IList<T> ToList<T>(DataTable datas) where T : class, new()
{
IList<T> list = new List<T>();
if ((datas != null) && (datas.Rows.Count != 0))
{
PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (DataRow row in datas.Rows)
{
T local = Activator.CreateInstance<T>();
foreach (DataColumn column in datas.Columns)
{
object obj2 = null;
if (row.RowState == DataRowState.Deleted)
{
obj2 = row[column, DataRowVersion.Original];
}
else
{
obj2 = row[column];
}
if (obj2 != DBNull.Value)
{
foreach (PropertyInfo info in properties)
{
if (column.ColumnName.Equals(info.Name, StringComparison.CurrentCultureIgnoreCase))
{
info.SetValue(local, obj2, null);
}
}
}
}
list.Add(local);
}
}
return list;
}
}
}

public static T ToEnum<T>(object obj, T defaultEnum)
{
string str = To<string>(obj);

if (Enum.IsDefined(typeof(T),str))
return (T)Enum.Parse(typeof(T),str);

int num;
if (int.TryParse(str, out num))
{
if (Enum.IsDefined(typeof(T), num))
return (T)Enum.ToObject(typeof(T), num);
}

return defaultEnum;
}

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

namespace Common
{
public partial class Generics
{
/// <summary>
/// 转换object为 T 值
/// </summary>
/// <typeparam name="T">T 类型</typeparam>
/// <param name="obj">要被转换的值</param>
/// <returns>T 类型值</returns>
public static T To<T>(object obj)
{
return To<T>(obj, default(T));
}

/// <summary>
/// 转换object为 T 值
/// </summary>
/// <typeparam name="T">T 类型</typeparam>
/// <param name="obj">要被转换的值</param>
/// <returns>T 类型值</returns>
public static T To<T>(object obj,T defaultValue)
{
if (obj==null)
{
return defaultValue;
}
else if (obj is T)
{
return (T)obj;
}
else
{
try
{
Type conversionType = typeof(T);
object obj2 = null;
if (conversionType.Equals(typeof(Guid)))
obj2 = new Guid(Convert.ToString(obj));
else
obj2 = Convert.ChangeType(obj, conversionType);
return (T)obj2;
}
catch (Exception)
{
return defaultValue;
}
}
}

/// <summary>
/// 填充客户端提交的值到 T 对象  如appinfo = AppConvert.To<Appinfo>(context.Request.Form);
/// </summary>
/// <typeparam name="T">T 类</typeparam>
/// <param name="datas">客户端提交的值</param>
/// <returns>T 对象</returns>
public static T To<T>(NameValueCollection datas) where T : class, new()
{
Type type = typeof(T);
string[] strArray = type.FullName.Split(new char[] { '.' });
string str = strArray[strArray.Length - 1];
PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
T local = Activator.CreateInstance<T>();
foreach (string str2 in datas.AllKeys)
{
string str3 = datas[str2];
if (!string.IsNullOrEmpty(str3))
{
str3 = str3.TrimEnd(new char[0]);
}
foreach (PropertyInfo info in properties)
{
string str4 = string.Format("{0}.{1}", str, info.Name);
if (str2.Equals(info.Name, StringComparison.CurrentCultureIgnoreCase) || str2.Equals(str4, StringComparison.CurrentCultureIgnoreCase))
{
string typeName = info.PropertyType.ToString();
if (info.PropertyType.IsGenericType)
{
typeName = info.PropertyType.GetGenericArguments()[0].ToString();
}
object nullInternal = GetNullInternal(info.PropertyType);
Type conversionType = Type.GetType(typeName, false);
if (!string.IsNullOrEmpty(str3))
{
nullInternal = Convert.ChangeType(str3, conversionType);
}
info.SetValue(local, nullInternal, null);
}
}
}
return local;
}

#region 获取类型的默认值
//另一种获取默认值的方法
private static object GetDefaultValue(Type type)
{
object value = null;

if (type.IsValueType)
value = Activator.CreateInstance(type);
else
value = null;

return value;
}

// 获取指定类型的默认值.引用类型(包含String)的默认值为null
private static T DefaultValue<T>()
{
return default(T);
}

//获取默认值
private static object GetNullInternal(Type type)
{
if (type.IsValueType)
{
if (type.IsEnum)
{
return GetNullInternal(Enum.GetUnderlyingType(type));
}
if (type.IsPrimitive)
{
if (type == typeof(int))
{
return 0;
}
if (type == typeof(double))
{
return 0.0;
}
if (type == typeof(short))
{
return (short)0;
}
if (type == typeof(sbyte))
{
return (sbyte)0;
}
if (type == typeof(long))
{
return 0L;
}
if (type == typeof(byte))
{
return (byte)0;
}
if (type == typeof(ushort))
{
return (ushort)0;
}
if (type == typeof(uint))
{
return 0;
}
if (type == typeof(ulong))
{
return (ulong)0L;
}
if (type == typeof(ulong))
{
return (ulong)0L;
}
if (type == typeof(float))
{
return 0f;
}
if (type == typeof(bool))
{
return false;
}
if (type == typeof(char))
{
return '\0';
}
}
else
{
if (type == typeof(DateTime))
{
return DateTime.MinValue;
}
if (type == typeof(decimal))
{
return 0M;
}
if (type == typeof(Guid))
{
return Guid.Empty;
}
if (type == typeof(TimeSpan))
{
return new TimeSpan(0, 0, 0);
}
}
}
return null;
}
#endregion
}
}

　　　　/// <summary>
/// 转换为string类型 defult为string.Empty
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string ToString(object obj)
{
return To<string>(obj,string.Empty);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Dynamic;

namespace Common
{
public partial class TreeData
{
public static List<dynamic> ListToTreeData<T>(List<T> source, string ID, string PID) where T : class, new()
{
Action<List<dynamic>, T, dynamic> AddItem = (parent, item, Recursive) =>
{
var childrens = new List<dynamic>();
var thisitem = ZGeneric.GetDictionaryValues(item);

source.FindAll(o => ZGeneric.GetValue(item, ID).Equals(ZGeneric.GetValue(o, PID)))
.ForEach(subitem => { Recursive(childrens, subitem, Recursive); });

thisitem.Add("children", childrens);
parent.Add(thisitem);
};

var target = new List<dynamic>();
source.FindAll(m => { return !source.Exists(n => ZGeneric.GetValue(n, ID).Equals(ZGeneric.GetValue(m, PID))); })
.ForEach(item => AddItem(target, item, AddItem));

return target;
}

public static List<T> TreeDataToList<T>(List<dynamic> source)
{
Action<List<dynamic>, List<T>, dynamic> AddItem = (mysource, mytarget, Recursive) =>
{
foreach (var oldrow in mysource)
{
var newrow = ZGeneric.CreateNew<T>();
var dictionary = (IDictionary<string, object>)ZGeneric.GetDictionaryValues(oldrow);

var childern = dictionary["childern"] as List<dynamic>;
if (childern.Count > 0) Recursive(mysource, mytarget, Recursive);

foreach (var property in dictionary)
if (property.Key != "children")
ZGeneric.SetValue(newrow, property.Key, property.Value);

mytarget.Add(newrow);
}
};

var target = new List<T>();
AddItem(source, target, AddItem);

return target;
}
}
}