Objeto C#.NET estende ToJson/Serialize/Deserialize

usando o sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando System.Reflection;
usando System.Data;
usando System.Data.Common;
usando System.Web.Script.Serialization;
usando System.IO;
usando System.Security.Cryptography;
usando System.ComponentModel;
usando System.Runtime.Serialization.Formatters.Binary;
usando System.xml.Serialization;

espaço de nomes Pub.Class {
classe estática pública ObjectExtensions {

string estática pública ToJson(este objeto obj){
retornarToJson(obj,nulo);
}
string estática pública ToJson(este objeto obj, IEnumerable jsonConverters) {
serializador JavascriptSerializer = novo JavaScriptSerializer();
if (jsonConverters != null) serializer.RegisterConverters(jsonConverters ?? new JavaScriptConverter[0]);
retornar serializador.Serialize(obj);
}

public static T ConvertTo(este valor do objeto) { return value.ConvertTo(default(T)); }
public static T ConvertTo(este valor do objeto, T defaultValue) {
if (valor! = nulo) {
var targetType = typeof(T);

var conversor = TypeDescriptor.GetConverter(valor);
if (conversor! = nulo) {
if(converter.CanConvertTo(targetType)) return (T) converter.ConvertTo(valor, targetType);
}

conversor = TypeDescriptor.GetConverter(targetType);
if (conversor! = nulo) {
tente { if(converter.CanConvertFrom(value.GetType())) return (T) converter.ConvertFrom(value); } pegar {}
}
}
retornar valorpadrão;
}
public static T ConvertTo(este valor do objeto, T defaultValue, bool ignoreException) {
if(ignoreException) {
tentar {
valor de retorno.ConvertTo();
}
pegar {
retornar valorpadrão;
}
}
valor de retorno.ConvertTo();
}

public static int ToInt(este objeto strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
byte estático público ToTinyInt (este objeto strValue, byte defValue) { byte def = 0; byte.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static short ToSmallInt(este objeto strValue, short defValue) { short def = 0; short.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static decimal ToDecimal(este objeto strValue, decimal defValue) { decimal def = 0; decimal.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static float ToFloat(este objeto strValue, float defValue) { float def = 0; float.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static Int64 ToBigInt(este objeto strValue, Int64 defValue) { Int64 def = 0; Int64.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static decimal ToMoney (este objeto strValue, decimal defValue) { decimal def = 0; decimal.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static int ToInteger(este objeto strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), out def); retornar def == 0? defValor: def; }
public static bool ToBool(este objeto ExPRession, bool defValue) {
if (Expressão! = Nulo) {
if (string.Compare(Expression.ToString(), "true", true) == 0) retornar verdadeiro;
if (string.Compare(Expression.ToString(), "false", true) == 0) retornar falso;
if (string.Compare(Expression.ToString(), "1", verdadeiro) == 0) retornar verdadeiro;
if (string.Compare(Expression.ToString(), "0", true) == 0) retornar falso;
}
return valorDef;
}
public static int ToInt(este objeto strValue) { return strValue.ToInt(0); }
byte estático público ToTinyInt (este objeto strValue) { return strValue.ToTinyInt (0); }
public static short ToSmallInt(este objeto strValue) { return strValue.ToSmallInt(0); }
public static decimal ToDecimal(este objeto strValue) { return strValue.ToDecimal(0); }
public static float ToFloat(este objeto strValue) { return strValue.ToFloat(0); }
public static Int64 ToBigInt(este objeto strValue) { return strValue.ToBigInt(0); }
public static decimal ToMoney(este objeto strValue) { return strValue.ToMoney(0); }
public static int ToInteger(este objeto strValue) { return strValue.ToInteger(0); }
public static bool ToBool (este objeto strValue) { return strValue.ToBool (false); }

objeto estático público InvokeMethod(este objeto obj, string methodName, params object[] parâmetros) {
return InvokeMethod(obj, nomemétodo, parâmetros);
}
public static T InvokeMethod(este objeto obj, string methodName) {
return InvokeMethod(obj, nomeMetodo, null);
}
public static T InvokeMethod(este objeto obj, string methodName, params object[] parâmetros) {
var tipo = obj.GetType();
var método = type.GetMethod(nomedometodo);

if(método == null) throw new ArgumentException(string.Format("Método '{0}' não encontrado.", methodName), methodName);

var valor = método.Invoke(obj, parâmetros);
retorno (o valor é T? (T) valor: padrão (T));
}

objeto estático público GetPropertyValue(este objeto obj, string propertyName) {
return GetPropertyValue(obj, nomedapropriedade, null);
}
public static T GetPropertyValue(este objeto obj, string propertyName) {
return GetPropertyValue(obj, nomedapropriedade, padrão(T));
}
public static T GetPropertyValue(este objeto obj, string propertyName, T defaultValue) {
var tipo = obj.GetType();
var propriedade = type.GetProperty(propertyName);

if(property == null) throw new ArgumentException(string.Format("Propriedade '{0}' não encontrada.", propertyName), propertyName);

var valor = propriedade.GetValue(obj, null);
return (o valor é T? (T) valor: defaultValue);
}
public static void SetPropertyValue(este objeto obj, string propertyName, valor do objeto) {
var tipo = obj.GetType();
var propriedade = type.GetProperty(propertyName);

if(property == null) throw new ArgumentException(string.Format("Propriedade '{0}' não encontrada.", propertyName), propertyName);

propriedade.SetValue(obj, valor, nulo);
}

public static T GetAttribute(este objeto obj) onde T: Attribute {
return GetAttribute(obj, verdadeiro);
}
public static T GetAttribute(este objeto obj, bool includeInherited) onde T: Atributo {
var tipo = (obj como tipo ?? obj.GetType());
var atributos = type.GetCustomAttributes(typeof(T), includeInherited);
if((atributos! = nulo) && (atributos.Comprimento > 0)) {
return (atributos[0] como T);
}
retornar nulo;
}

public static IEnumerable GetAttributes(este objeto obj) onde T: Atributo {
return GetAttributes(obj);
}
public static IEnumerable GetAttributes(este objeto obj, bool includeInherited) onde T: Atributo {
var tipo = (obj como tipo ?? obj.GetType());
foreach(atributo var em type.GetCustomAttributes(typeof(T), includeInherited)) {
if (atributo é T) atributo de retorno de rendimento (T);
}
}

public static bool IsType(este objeto obj, Tipo tipo) {
retornar obj.GetType().Equals(tipo);
}
public static T ToType(este valor do objeto) { return (T)valor; }
public static bool IsArray(este objeto obj) {
retornar obj.IsType(typeof(System.Array));
}
public static bool IsDBNull(este objeto obj) {
retornar obj.IsType(typeof(DBNull));
}

public static byte[] Serialize(valor deste objeto) {
MemoryStream ms = new MemoryStream();
BinaryFormatter bf1 = new BinaryFormatter();
bf1.Serialize(ms, valor);
return ms.ToArray();
}

public static void CheckOnNull(este objeto @este, string parâmetroNome) {
if(@this.IsNull()) throw new ArgumentNullException(parameterName);
}
public static void CheckOnNull(este objeto @this, string parâmetroNome, string mensagem) {
if(@this.IsNull()) throw new ArgumentNullException(parameterName, mensagem);
}
public static bool IsNull(este objeto @este) {
retornar @isto == nulo;
}
public static bool IsNotNull(este objeto @este) {
return [email protected] ();
}
public static T UnsafeCast(valor deste objeto) {
valor de retorno.IsNull() ? padrão(T): valor (T);
}
public static T SafeCast(valor deste objeto) {
o valor de retorno é T? valor.UnsafeCast() : padrão(T);
}
public static bool InstanceOf(valor deste objeto) {
o valor de retorno é T;
}

public static void SerializeXmlFile(este objeto o, string fileName) {
serializador XmlSerializer = new XmlSerializer(o.GetType());
if (!FileFolder.FileExists(nomeDoArquivo)) retornar;
usando (FileStream stream = new FileStream(fileName, FileMode.Create, Fileaccess.Write)) serializer.Serialize(stream, o);
}
public static T DeserializeXmlFile(string nomeArquivo) {
Para;
serializador XmlSerializer = new XmlSerializer(typeof(T));
usando (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read)) o = (T)serializer.Deserialize(stream);
retornar ó;
}

string estática pública SerializeXml(este objeto o) {
serializador XmlSerializer = new XmlSerializer(o.GetType());
StringBuilder stringBuilder = new StringBuilder();
usando (TextWriter textWriter = new StringWriter(stringBuilder)) serializer.Serialize(textWriter, o);
retornar stringBuilder.ToString();
}
public static T DeserializeXml(esta string xml) {
return (T)Deserialize(xml, typeof(T));
}
objeto estático público Deserialize(string xml, Type type) {
objeto o;
serializador XmlSerializer = novo XmlSerializer(tipo);
usando (TextReader textReader = new StringReader(xml)) o = serializer.Deserialize(textReader);
retornar ó;
}

public static void Write(este objeto o) { Msg.Write(o); }
public static void WriteEnd(este objeto o) { Msg.WriteEnd(o); }
}
}