使用系统；
使用 System.Collections.Generic；
使用 System.Linq；
使用系统文本；
使用系统反射；
使用系统数据；
使用 System.Data.Common；
使用 System.Web.Script.Serialization；
使用系统.IO；
使用系统.安全.密码学；
使用 System.ComponentModel；
使用 System.Runtime.Serialization.Formatters.Binary；
使用 System.xml.Serialization；
命名空间 Pub.Class {
公共静态类 ObjectExtensions {
公共静态字符串ToJson（此对象obj）{
返回 ToJson(obj, null);
}
公共静态字符串 ToJson(此对象 obj, IEnumerable<javaScriptConverter> jsonConverters) {
JavascriptSerializer 序列化器 = new JavaScriptSerializer();
if (jsonConverters != null) serializer.RegisterConverters(jsonConverters ?? new JavaScriptConverter[0]);
返回序列化器.Serialize(obj);
}
公共静态 T ConvertTo<T>(this 对象值) { return value.ConvertTo(default(T)); }
public static T ConvertTo<T>(this 对象值, T defaultValue) {
如果（值！=空）{
var targetType = typeof(T);
var转换器= TypeDescriptor.GetConverter(值);
如果（转换器！= null）{
if(converter.CanConvertTo(targetType)) return (T) converter.ConvertTo(value, targetType);
}
转换器 = TypeDescriptor.GetConverter(targetType);
如果（转换器！= null）{
尝试{ if(converter.CanConvertFrom(value.GetType())) return (T) converter.ConvertFrom(value); } 抓住 {}
}
}
返回默认值；
}
公共静态 T ConvertTo<T>(此对象值, T defaultValue, boolignoreException) {
如果（忽略异常）{
尝试 {
返回值。ConvertTo<T>();
}
抓住 {
返回默认值；
}
}
返回值。ConvertTo<T>();
}
公共静态 int ToInt(这个对象 strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态字节ToTinyInt（这个对象strValue，字节defValue）{字节def = 0; byte.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态短ToSmallInt（这个对象strValue，短defValue）{短def = 0; Short.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态小数 ToDecimal(this 对象 strValue, 小数 defValue) { 小数 def = 0; Decimal.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态浮动ToFloat（这个对象strValue，浮动defValue）{浮动def = 0; float.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态 Int64 ToBigInt(this 对象 strValue, Int64 defValue) { Int64 def = 0; Int64.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态小数 ToMoney(this 对象 strValue, 小数 defValue) { 小数 def = 0; Decimal.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态 int ToInteger(这个对象 strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), out def);返回def == 0 ? def值：def； }
公共静态 bool ToBool(这个对象 ExPRession, bool defValue) {
if (表达式!= null) {
if (string.Compare(Expression.ToString(), "true", true) == 0) 返回 true;
if (string.Compare(Expression.ToString(), "false", true) == 0) 返回 false;
if (string.Compare(Expression.ToString(), "1", true) == 0) 返回 true;
if (string.Compare(Expression.ToString(), "0", true) == 0) 返回 false;
}
返回定义值；
}
公共静态 int ToInt(this 对象 strValue) { return strValue.ToInt(0); }
公共静态字节ToTinyInt（这个对象strValue）{返回strValue.ToTinyInt（0）; }
公共静态短ToSmallInt（这个对象strValue）{返回strValue.ToSmallInt（0）; }
公共静态小数ToDecimal(this object strValue) { return strValue.ToDecimal(0); }
公共静态浮动ToFloat（这个对象strValue）{返回strValue.ToFloat（0）; }
公共静态 Int64 ToBigInt(this 对象 strValue) { return strValue.ToBigInt(0); }
公共静态十进制ToMoney(this object strValue) { return strValue.ToMoney(0); }
公共静态 int ToInteger(this 对象 strValue) { return strValue.ToInteger(0); }
公共静态 bool ToBool(this 对象 strValue) { return strValue.ToBool(false); }
public static object InvokeMethod(this object obj, string methodName, params object[] 参数) {
return InvokeMethod<对象>(obj, 方法名, 参数);
}
公共静态 T InvokeMethod <T>（此对象 obj，字符串方法名称）{
return InvokeMethod<T>(obj, 方法名, null);
}
public static T InvokeMethod<T>(this 对象 obj, string methodName, params object[] 参数) {
var type = obj.GetType();
var method = type.GetMethod(方法名);
if(method == null) throw new ArgumentException(string.Format("未找到方法'{0}'。", methodName), methodName);
var value = method.Invoke(obj, 参数);
返回（值是T？（T）值：默认（T））；
}
公共静态对象 GetPropertyValue(此对象 obj, 字符串 propertyName) {
返回 GetPropertyValue<对象>(obj, propertyName, null);
}
公共静态 T GetPropertyValue<T>(此对象 obj, 字符串 propertyName) {
返回 GetPropertyValue<T>(obj, propertyName, default(T));
}
公共静态 T GetPropertyValue<T>(此对象 obj, 字符串 propertyName, T defaultValue) {
var type = obj.GetType();
var 属性 = type.GetProperty(propertyName);
if(property == null) throw new ArgumentException(string.Format("未找到属性 '{0}'。", propertyName), propertyName);
var value = property.GetValue(obj, null);
返回（值是 T ？ (T) 值：defaultValue）；
}
公共静态无效SetPropertyValue（此对象obj，字符串属性名称，对象值）{
var type = obj.GetType();
var 属性 = type.GetProperty(propertyName);
if(property == null) throw new ArgumentException(string.Format("未找到属性 '{0}'。", propertyName), propertyName);
property.SetValue(obj, 值, null);
}
公共静态 T GetAttribute<T>(this 对象 obj) 其中 T : 属性 {
返回 GetAttribute<T>(obj, true);
}
公共静态 T GetAttribute<T>(this 对象 obj, bool includeInherited) 其中 T : 属性 {
var type = (obj as Type ?? obj.GetType());
var 属性 = type.GetCustomAttributes(typeof(T), includeInherited);
if((属性！= null) && (attributes.Length > 0)) {
返回（属性[0]为T）；
}
返回空值；
}
公共静态 IEnumerable<T> GetAttributes<T>(this 对象 obj) 其中 T : 属性 {
返回 GetAttributes<T>(obj);
}
公共静态 IEnumerable<T> GetAttributes<T>(this 对象 obj, bool includeInherited) 其中 T : 属性 {
var type = (obj as Type ?? obj.GetType());
foreach(type.GetCustomAttributes(typeof(T), includeInherited)) { 中的 var 属性
if(属性是T)yield return(T)属性；
}
}
公共静态布尔IsType（此对象obj，类型类型）{
返回 obj.GetType().Equals(type);
}
public static T ToType<T>(this 对象值) { return (T)value; }
公共静态布尔IsArray（这个对象obj）{
返回 obj.IsType(typeof(System.Array));
}
公共静态布尔IsDBNull（这个对象obj）{
返回 obj.IsType(typeof(DBNull));
}
公共静态字节[]序列化（此对象值）{
MemoryStream ms = new MemoryStream();
BinaryFormatter bf1 = new BinaryFormatter();
bf1.Serialize(ms, 值);
返回 ms.ToArray();
}
公共静态无效CheckOnNull（这个对象@this，字符串参数名称）{
if(@this.IsNull()) 抛出 new ArgumentNullException(parameterName);
}
public static void CheckOnNull(this 对象 @this, 字符串参数名, 字符串消息) {
if(@this.IsNull()) 抛出 new ArgumentNullException(parameterName, message);
}
公共静态布尔IsNull（这个对象@this）{
返回@this == null；
}
公共静态布尔IsNotNull（这个对象@this）{
return [email protected] ();
}
公共静态 T UnsafeCast<T>（此对象值）{
返回值.IsNull() ?默认（T）：（T）值；
}
公共静态 T SafeCast<T>（此对象值）{
返回值是 T ? value.UnsafeCast<T>() : 默认(T);
}
public static bool InstanceOf<T>(这个对象值) {
返回值为T；
}
公共静态无效SerializeXmlFile（此对象o，字符串文件名）{
XmlSerializer 序列化器 = new XmlSerializer(o.GetType());
if (!FileFolder.FileExists(文件名)) 返回;
使用（FileStream流=新FileStream（文件名，FileMode.Create，Fileaccess.Write））serializer.Serialize（stream，o）;
}
公共静态 T DeserializeXmlFile<T>（字符串文件名）{
到;
XmlSerializer 序列化器 = new XmlSerializer(typeof(T));
使用 (FileStream 流 = new FileStream(fileName, FileMode.Open, FileAccess.Read)) o = (T)serializer.Deserialize(stream);
返回o；
}
公共静态字符串SerializeXml（此对象o）{
XmlSerializer 序列化器 = new XmlSerializer(o.GetType());
StringBuilder stringBuilder = new StringBuilder();
使用 (TextWriter textWriter = new StringWriter(stringBuilder)) 序列化器.Serialize(textWriter, o);
返回 stringBuilder.ToString();
}
公共静态 T DeserializeXml<T>（此字符串 xml）{
返回（T）反序列化（xml，typeof（T））；
}
公共静态对象反序列化（字符串xml，类型类型）{
对象o；
XmlSerializer 序列化器 = new XmlSerializer(type);
使用 (TextReader textReader = new StringReader(xml)) o = serializer.Deserialize(textReader);
返回o；
}
公共静态无效写入（这个对象o）{Msg.Write（o）; }
公共静态无效WriteEnd（这个对象o）{Msg.WriteEnd（o）; }
}
}