usando 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;
utilizando System.Security.Cryptography;
usando System.ComponentModel;
usando System.Runtime.Serialization.Formatters.Binary;
usando System.xml.Serialization;
espacio de nombres Pub.Class {
Extensiones de objeto de clase estática pública {
cadena estática pública ToJson (este objeto obj) {
devolver ToJson(obj, nulo);
}
cadena estática pública ToJson (este objeto obj, IEnumerable<javaScriptConverter> jsonConverters) {
Serializador JavascriptSerializer = nuevo JavaScriptSerializer();
if (jsonConverters! = null) serializer.RegisterConverters(jsonConverters?? new JavaScriptConverter[0]);
devolver serializador.Serialize(obj);
}
public static T ConvertTo<T>(este valor de objeto) { valor de retorno.ConvertTo(default(T)); }
public static T ConvertTo<T>(este valor de objeto, T defaultValue) {
si(valor!= nulo) {
var tipo de destino = tipo de (T);
convertidor var = TypeDescriptor.GetConverter(valor);
si (convertidor! = nulo) {
if(converter.CanConvertTo(targetType)) return (T) convertidor.ConvertTo(valor, targetType);
}
convertidor = TypeDescriptor.GetConverter(targetType);
si (convertidor! = nulo) {
intente { if(converter.CanConvertFrom(value.GetType())) return (T) convertidor.ConvertFrom(valor); } atrapar {}
}
}
devolver valor predeterminado;
}
public static T ConvertTo<T>(este valor de objeto, T defaultValue, bool ignoreException) {
si (ignorar excepción) {
intentar {
valor de retorno.ConvertTo<T>();
}
atrapar {
devolver valor predeterminado;
}
}
valor de retorno.ConvertTo<T>();
}
public static int ToInt(este objeto strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
byte estático público ToTinyInt (este objeto strValue, byte defValue) { byte def = 0; byte.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
público estático corto ToSmallInt (este objeto strValue, short defValue) { short def = 0; short.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
decimal estático público ToDecimal (este objeto strValue, decimal defValue) { decimal def = 0; decimal.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
flotador estático público ToFloat (este objeto strValue, float defValue) { float def = 0; float.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
public static Int64 ToBigInt (este objeto strValue, Int64 defValue) { Int64 def = 0; Int64.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
decimal estático público ToMoney (este objeto strValue, decimal defValue) { decimal def = 0; decimal.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
public static int ToInteger(este objeto strValue, int defValue) { int def = 0; int.TryParse(strValue.ToString(), fuera def); devolver definición == 0? defValor: def; }
bool estático público ToBool (este objeto ExPRession, bool defValue) {
si (Expresión! = nulo) {
if (string.Compare(Expression.ToString(), "true", true) == 0) devuelve verdadero;
if (string.Compare(Expression.ToString(), "false", true) == 0) devuelve falso;
if (string.Compare(Expression.ToString(), "1", verdadero) == 0) devuelve verdadero;
if (string.Compare(Expression.ToString(), "0", true) == 0) devuelve falso;
}
devolver valor def;
}
public static int ToInt(este objeto strValue) { return strValue.ToInt(0); }
byte estático público ToTinyInt (este objeto strValue) { return strValue.ToTinyInt(0); }
público estático corto ToSmallInt (este objeto strValue) { return strValue.ToSmallInt(0); }
decimal estático público ToDecimal (este objeto strValue) { return strValue.ToDecimal(0); }
flotador estático público ToFloat (este objeto strValue) { return strValue.ToFloat(0); }
public static Int64 ToBigInt (este objeto strValue) { return strValue.ToBigInt(0); }
decimal estático público ToMoney (este objeto strValue) { return strValue.ToMoney (0); }
public static int ToInteger(este objeto strValue) { return strValue.ToInteger(0); }
bool estático público ToBool (este objeto strValue) { return strValue.ToBool (falso); }
objeto estático público InvokeMethod (este objeto obj, cadena nombre del método, parámetros objeto [] parámetros) {
return InvokeMethod<objeto>(obj, nombre del método, parámetros);
}
public static T InvokeMethod<T>(este objeto obj, cadena nombre del método) {
return InvokeMethod<T>(obj, nombre del método, nulo);
}
público estático T InvokeMethod<T>(este objeto obj, cadena nombre del método, parámetros objeto[] parámetros) {
tipo var = obj.GetType();
método var = tipo.GetMethod(nombremétodo);
if(método == null) throw new ArgumentException(string.Format("Método '{0}' no encontrado.", nombre_método), nombre_método);
valor var = método.Invoke(obj, parámetros);
retorno (el valor es T? (T) valor: predeterminado (T));
}
objeto estático público GetPropertyValue (este objeto obj, cadena nombre de propiedad) {
return GetPropertyValue<objeto>(obj, nombrePropiedad, nulo);
}
public static T GetPropertyValue<T>(este objeto obj, cadena nombre de propiedad) {
return GetPropertyValue<T>(obj, propertyName, default(T));
}
public static T GetPropertyValue<T>(este objeto obj, cadena propertyName, T defaultValue) {
tipo var = obj.GetType();
var propiedad = tipo.GetProperty(nombredepropiedad);
if(property == null) throw new ArgumentException(string.Format("Propiedad '{0}' no encontrada.", nombrePropiedad), nombrePropiedad);
valor var = propiedad.GetValue(obj, nulo);
retorno (el valor es T? (T) valor: valor predeterminado);
}
public static void SetPropertyValue (este objeto obj, cadena nombre de propiedad, valor del objeto) {
tipo var = obj.GetType();
var propiedad = tipo.GetProperty(nombredepropiedad);
if(property == null) throw new ArgumentException(string.Format("Propiedad '{0}' no encontrada.", nombrePropiedad), nombrePropiedad);
propiedad.SetValue(obj, valor, nulo);
}
público estático T GetAttribute<T>(este objeto obj) donde T: Atributo {
devolver GetAttribute<T>(obj, verdadero);
}
público estático T GetAttribute<T>(este objeto obj, bool includeInherited) donde T: Atributo {
var tipo = (obj como Tipo ?? obj.GetType());
var atributos = type.GetCustomAttributes(typeof(T), includeInherited);
if((atributos!= nulo) && (atributos.Longitud > 0)) {
retorno (atributos [0] como T);
}
devolver nulo;
}
IEnumerable estático público <T> GetAttributes <T> (este objeto obj) donde T: Atributo {
return ObtenerAtributos<T>(obj);
}
público estático IEnumerable<T> GetAttributes<T>(este objeto obj, bool includeInherited) donde T: Atributo {
var tipo = (obj como Tipo ?? obj.GetType());
foreach(atributo var en type.GetCustomAttributes(typeof(T), includeInherited)) {
si (el atributo es T) produce el atributo de retorno (T);
}
}
bool estático público IsType (este objeto obj, tipo de tipo) {
devolver obj.GetType().Equals(tipo);
}
public static T ToType<T>(este valor de objeto) { valor de retorno (T); }
bool estático público IsArray (este objeto obj) {
devolver obj.IsType(typeof(System.Array));
}
bool estático público IsDBNull (este objeto obj) {
devolver obj.IsType(typeof(DBNull));
}
byte estático público [] Serializar (este valor de objeto) {
MemoryStream ms = nuevo MemoryStream();
BinaryFormatter bf1 = nuevo BinaryFormatter();
bf1.Serialize(ms, valor);
devolver ms.ToArray();
}
public static void CheckOnNull (este objeto @this, nombre del parámetro de cadena) {
if(@this.IsNull()) lanza una nueva ArgumentNullException(parameterName);
}
public static void CheckOnNull (este objeto @this, nombre del parámetro de cadena, mensaje de cadena) {
if(@this.IsNull()) lanza una nueva excepción ArgumentNullException(nombre del parámetro, mensaje);
}
bool estático público IsNull (este objeto @this) {
devolver @this == nulo;
}
bool estático público IsNotNull (este objeto @this) {
retorno [email protected] ();
}
public static T UnsafeCast<T>(este valor de objeto) {
valor de retorno.IsNull()? predeterminado(T): (T)valor;
}
public static T SafeCast<T>(este valor de objeto) {
¿El valor de retorno es T? valor.UnsafeCast<T>() : predeterminado(T);
}
public static bool InstanceOf<T>(este valor de objeto) {
el valor de retorno es T;
}
public static void SerializeXmlFile (este objeto o, cadena nombre de archivo) {
Serializador XmlSerializer = new XmlSerializer(o.GetType());
si (!FileFolder.FileExists(fileName)) regresa;
usando (FileStream stream = new FileStream(fileName, FileMode.Create, Fileaccess.Write)) serializer.Serialize(stream, o);
}
público estático T DeserializeXmlFile<T>(nombre de archivo de cadena) {
A;
Serializador XmlSerializer = nuevo XmlSerializer (tipo de (T));
usando (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read)) o = (T)serializer.Deserialize(stream);
volver o;
}
cadena estática pública SerializeXml (este objeto o) {
Serializador XmlSerializer = new XmlSerializer(o.GetType());
StringBuilder stringBuilder = nuevo StringBuilder();
usando (TextWriter textWriter = new StringWriter(stringBuilder)) serializer.Serialize(textWriter, o);
devolver stringBuilder.ToString();
}
public static T DeserializeXml<T>(esta cadena xml) {
return (T)Deserializar(xml, tipode(T));
}
objeto estático público Deserializar (cadena xml, tipo tipo) {
objeto o;
Serializador XmlSerializer = nuevo XmlSerializer (tipo);
usando (TextReader textReader = new StringReader(xml)) o = serializer.Deserialize(textReader);
volver o;
}
escritura vacía estática pública (este objeto o) { Msg.Write(o); }
public static void WriteEnd(este objeto o) { Msg.WriteEnd(o); }
}
}