C#.NET Object扩展 ToJson/Serialize/Deserialize

使用系统；
使用 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 jsonConverters) {
JavascriptSerializer 序列化器 = new JavaScriptSerializer();
if (jsonConverters != null) serializer.RegisterConverters(jsonConverters ?? new JavaScriptConverter[0]);
返回序列化器.Serialize(obj);
}

公共静态 T ConvertTo(this 对象值) { return value.ConvertTo(default(T)); }
public static T ConvertTo(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 defaultValue, boolignoreException) {
如果（忽略异常）{
尝试 {
返回值。ConvertTo();
}
抓住 {
返回默认值；
}
}
返回值。ConvertTo();
}

公共静态 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 （此对象 obj，字符串方法名称）{
return InvokeMethod(obj, 方法名, null);
}
public static T InvokeMethod(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(此对象 obj, 字符串 propertyName) {
返回 GetPropertyValue(obj, propertyName, default(T));
}
公共静态 T GetPropertyValue(此对象 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(this 对象 obj) 其中 T : 属性 {
返回 GetAttribute(obj, true);
}
公共静态 T GetAttribute(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 GetAttributes(this 对象 obj) 其中 T : 属性 {
返回 GetAttributes(obj);
}
公共静态 IEnumerable GetAttributes(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(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（此对象值）{
返回值.IsNull() ?默认（T）：（T）值；
}
公共静态 T SafeCast（此对象值）{
返回值是 T ? value.UnsafeCast() : 默认(T);
}
public static bool InstanceOf(这个对象值) {
返回值为T；
}

公共静态无效SerializeXmlFile（此对象o，字符串文件名）{
XmlSerializer 序列化器 = new XmlSerializer(o.GetType());
if (!FileFolder.FileExists(文件名)) 返回;
使用（FileStream流=新FileStream（文件名，FileMode.Create，Fileaccess.Write））serializer.Serialize（stream，o）;
}
公共静态 T DeserializeXmlFile（字符串文件名）{
到;
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（此字符串 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）; }
}
}