THE .NET WAY » Trucos – – The .Net Way

Extension Methods en .NET

Emilio Torrens — Fri, 23 Dec 2011 10:43:49 +0000

Los ExtensionMethods nos permiten crear metodos que estén disponibles en todos los tipos de objetos que les definamos.

Por ejemplo podemos definir que todas nuestras clases tipo A tengan un método ToJson que devuelva una String con el Json creando el siguiente método:

public static string ToJson(this A o) {return JsonConvert.SerializeObject(o);}

Lo único que hay que hacer es using del namespace donde estén definidos los metodos.

En este ejemplo creamos un ExtensionMethod para que todos los objetos tengan el método ToJson, eso lo hacemos creando el método con Object, y después le añadimos un método al object String para que lo transforme en un Objeto Tipado

public static string ToJson(this Object o) {return JsonConvert.SerializeObject(o);}
public static T FromJson(this String str) {return JsonConvert.DeserializeObject(str);}

Aquí el Test:

public class MyClass
{
    public string value { get; set; }
    public int value2 { get; set; }        
}
 
[TestClass]
public class ExtensionMethodsTest
{
    [TestMethod]
    public void Test()
    {
        MyClass c = new MyClass {value = "hola",value2 = 50};
        string jsong = c.ToJson();
 
        MyClass c2 = jsong.FromJson();
    }
}

Personalizando los “cast” en .NET

Emilio Torrens — Tue, 20 Dec 2011 14:42:12 +0000

Aquí dejo un ejemplo de como personalizar el cast de nuestras clases a otras con implicit/explicit operator, por si nos interesa controlar la conversión.

Las clases:

public class ClassString
{
    public string value1 { get; set; }
    public string value2 { get; set; }
 
    public static implicit operator ClassInt(ClassString c2)
    {
        ClassInt c = new ClassInt
        {
            value1 = int.Parse(c2.value1),
            value2 = int.Parse(c2.value2)
        };
        return c;
    }
}
 
public class ClassInt
{
    public int value1 { get; set; }
    public int value2 { get; set; }
 
    public static explicit operator ClassString(ClassInt c2)
    {
        ClassString c = new ClassString
        {
            value1 = c2.value1.ToString(), 
            value2 = c2.value2.ToString()
        };
        return c;
    }                   
}

El test:

[TestMethod]
public void TestMethod1()
{
    ClassInt c1 = new ClassInt {value1 = 100,value2 = 200};
 
    ClassString c2 = (ClassString) c1;
    Assert.AreEqual(c2.value1, "100");
    Assert.AreEqual(c2.value2, "200");
 
    ClassInt c3 = c2;
    Assert.AreEqual(c3.value1, 100);
    Assert.AreEqual(c3.value2, 200);
}

Serialización: Cambiar el valor del XmlIgnore en runtime

Emilio Torrens — Tue, 15 Nov 2011 09:59:13 +0000

Aquí dejo un ejemplo de código que muestra como cambiar el valor del atributo [XmlIgnore] en tiempo de ejecución para evitar que se serialicen campos a nuestra conveniencia.

public class Person
 {
     [XmlIgnore]        
     public string Name { get; set; }
 
     [XmlIgnore]        
     public int Age { get; set; }
 }
 
 class Program
 {
     static void Main(string[] args)
     {
         Person p = new Person { Name = "El Nombre", Age = 35 };
 
         XmlAttributeOverrides xOverAtt = new XmlAttributeOverrides();
 
         //Hacermos que no serialize el Nombre
         XmlAttributes attrIgnoreTrue = new XmlAttributes();
         attrIgnoreTrue.XmlIgnore = true;
         xOverAtt.Add(typeof(Person), "Name", attrIgnoreTrue);
 
         XmlAttributes attrIgnoreFalse = new XmlAttributes();
         attrIgnoreFalse.XmlIgnore = false;
         xOverAtt.Add(typeof(Person), "Age", attrIgnoreFalse);
         
 
         XmlSerializer xSer = new XmlSerializer(typeof(Person), xOverAtt);
         xSer.Serialize(Console.Out,p);
         
         Console.ReadLine();
     }
 }

Cambiar el “element name” del tipo devuelto en los servicios web

Emilio Torrens — Thu, 10 Nov 2011 12:18:10 +0000

Los servicios web de ASP.NET tienen eso, que cuando quieres devolver tu objeto Person te lo renombran al nombre del método + result y te lo meten dentro de un método + response, así este código:

public class Person
{
    public string Name { get; set; }
}
 
[WebService(Namespace = "http://tempuri.org/")]
public class Service : System.Web.Services.WebService
{
    public Service () {
    }
 
    [WebMethod]
    public Person Get() {
        return new Person { Name = "Pepito" };
    }
    
}

Te generara esto:

Sin embargo usando atributos de Serializacion en la clase Person, definiéndole el nombre y el tipo, y de Soap en la clase Service conseguiremos que nos devuelva el objeto como lo hemos definido.

Así que este código:

[System.Xml.Serialization.XmlRootAttribute(ElementName = "Person", DataType = "Person")]
public class Person
{
    public string Name { get; set; }
}
 
[SoapDocumentService(Use=SoapBindingUse.Literal, ParameterStyle=SoapParameterStyle.Bare), WebService(Namespace = "http://tempuri.org/")]
public class Service : System.Web.Services.WebService
{
    public Service () {
    }
 
    [WebMethod]
    public Person Get() {
        return new Person { Name = "Pepito" };
    }
    
}

Te genera esto:

Serialización: Ignorar campos en tiempo ejecución

Mario Andujar — Tue, 08 Nov 2011 12:58:09 +0000

Aquí dejo un código de ejemplo para ignorar campos en tiempo de ejecución. La clave es crear un método llamado ShouldSerialized mas el nombre del campo.

public class ClassWithNullableElements
    {
 
        private Nullable endField;
 
        private Nullable startField;
 
        [System.Xml.Serialization.XmlAttributeAttribute(DataType = "date", AttributeName = "End")]
        public DateTime EndSerialized
        {
            get { return endField.Value; }
            set { endField = value; }
        }
        public bool ShouldSerializeEndSerialized()
        {
            return End.HasValue;
        }
        [XmlIgnore]
        public Nullable End
        {
            get
            {
                return this.endField;
            }
            set
            {
                this.endField = value;
            }
        }
 
        [System.Xml.Serialization.XmlAttributeAttribute(DataType = "date", AttributeName = "Start")]
        public DateTime StartSerialized
        {
            get { return startField.Value; }
            set { startField = value; }
        }
        public bool ShouldSerializeStartSerialized()
        {
            return Start.HasValue;
        }
        [XmlIgnore]
        public Nullable Start
        {
            get
            {
                return this.startField;
            }
            set
            {
                this.startField = value;
            }
        }
    }

Serializar y DeSerializar json y xml en .NET

Emilio Torrens — Wed, 05 Oct 2011 11:22:47 +0000

Aquí dejo una clase para hacer las serializaciones, la única dependencia es la librería Json.NET

public class Serializer
{
    public enum Format
    {
        json,xml
    }
    
    public static string Serialize(object data, Format format)
    {
        if (format == Format.json)
            return JsonConvert.SerializeObject(data);
        else
        {                
            using (StringWriter sw = new StringWriter())
            {
                XmlSerializer ser = new XmlSerializer(data.GetType());
                ser.Serialize(sw, data);
                sw.Flush();
                sw.Close();
                return sw.ToString();
            }
        }
    }
 
    public static T DeSerialize(string data, Format format)
    {
        if (format == Format.json)
            return JsonConvert.DeserializeObject(data);
        else
        {
            using (StringReader sr = new StringReader(data))
            {
                XmlSerializer ser = new XmlSerializer(typeof(T));
                return (T)ser.Deserialize(sr);
            }
        }
    }
 
}

Problemas con Mono y Microsoft.Practices.EnterpriseLibrary

Emilio Torrens — Wed, 17 Aug 2011 10:54:25 +0000

Si has intentado correr en Mono algún proyecto que utilice estas librerías de Microsoft, seguramente has recibido el habitual “Object not set …” con la mínima información.

Este problema estuvo a punto de tirarnos para atrás cuando estábamos intentando correr unos servicios web asp.net sobre Ubuntu, pero, como siempre pasa, alguien antes que nosotros lo había intentado y lo había solucionado.

El problema esta en “Common” y “Caching” así que puedes bajarte esas dos librerías desde aquí que ya que están corregidas para Mono, compilarlas con el MonoDevelop y substituir las de Microsoft por estas en tu proyecto.

Arrancar MongoDB en Ubuntu

Mario Andujar — Thu, 28 Jul 2011 12:36:50 +0000

Hay veces que MongoDB por algún motivo no arranca con el arranque de la maquina y es por un archivo que se genera donde se encuentran las bases de datos llamado mongo.lock (normalmente la ruta de las bases de datos, a no ser que se cambie, es /var/lib/mongo)

Para solucionarlo deberéis eliminarlo y arrancar de nuevo mongo con el siguiente comando:

$ sudo rm /var/lib/mongo/mongo.lock

$ sudo mongod –config /etc/mongodb.conf

Espero que os sirva

Renombrar una base de datos de Mongo

Emilio Torrens — Tue, 10 May 2011 09:43:26 +0000

La posibilidad de renombrar la base de datos en Mongo no existe, pero es relativamente sencillo ejecutando estos 3 comandos en la consola:

db.copyDatabase(‘oldName’,'newName’)
use ‘oldName’
db.dropDatabase()

Lo acabo de probar

Mongo Mapper para .NET

Emilio Torrens — Tue, 18 Jan 2011 12:29:59 +0000

Estoy trabajando en una librería para trabajar mas rápido con MongoDB y .NET, me he inspirado en el mongo_mapper para Ruby que he estado usando en el BOT de Twitter.

Utiliza el driver de CSharp para MongoDB y la idea es que la clase de trabajo herede de la de MongoMapper y por medio de Atributos definamos la Clave Primaria, los Índices y las Claves Externas, al heredar de la clase obtienes metodos de manipulación, y búsqueda de datos.

El código esta un poco verde para compartirlo pero aquí dejo un poco de código de test para que os hagáis una idea de hacia donde va la cosa.

using EtoolTech.MongoDB.Mapper.Attributes;
using EtoolTech.MongoDB.Mapper.Exceptions;
 
namespace EtoolTech.MongoDB.Mapper
{
    [MongoKey(KeyFields = "ID")]
    [MongoIndexes(Indexes = new[] {"Name", "ID,Country"})]
    public class Person : MongoMapper
    {
        public int ID { get; set; }
        public string Name { get; set; }
 
        [MongoRelation(ClassName = "Country", FieldName = "Code")]
        public string Country { get; set; }        
    }
 
    [MongoKey(KeyFields = "Code")]
    public class Country: MongoMapper
    {        
        public string Code { get; set; }
        public string Name { get; set; }
    }
 
    public class Tester
    {
        public void Test()
        {
            //Insert de Paises
            Country c = new Country { Code = "ES", Name = "España" };
            c.Save();
 
            c = new Country { Code = "UK", Name = "Reino Unido" };
            c.Save();
 
            c = new Country { Code = "US", Name = "Estados Unidos" };
            c.Save();
 
            //Insert de personas
            Person p = new Person { ID = 1, Name = "Pepito Perez", Country = "ES" };
            //Prueba de evento
            p.OnBeforeInsert += (s, e) => { ((Person)s).Name = "Juan Sin Miedo"; };
            p.Save();
 
            string Name = p.FindByKey(1).Name;
 
            //Comprobar la validacion
            p = new Person { ID = 2, Name = "Emilio Torrens", Country = "NL" };            
            try
            {
                p.Save();
            }
            catch (ValidateRelationException)
            {
                p.Country = "ES";
                p.Save();
            }
 
            //Comprobar que modifica por PK y no inserta uno nueva
            p = new Person { ID = 2, Name = "Emilio Torrens", Country = "UK" };
            p.Save();
 
            string CountryCode = p.FindByKey(2).Country;
 
            //probamos de recorrer una coleccion
            foreach (Country Country in c.All())
            {
                CountryCode = Country.Code;
            }
        }
    }
}