Un código que era:

Country c = new Country {Code ="US", Name = "Estados Unidos"};
c.Save<Country>();
 
Country c2 = Country.FindByKey<Country>("US");
 
List<Countries> = Country.FindAsList<Country>("Code", "US");

Se puede escribir:

Country c = new Country {Code ="US", Name = "Estados Unidos"};
c.Save();
 
Country c2 = new Country();
c.FillByKey("US");
 
List<Countries> Countries = new List<Countries>();
Countries.MongoFind("Code", "US");

Puedes ver ejemplos aquí.

La lista de extension methods es:

Para clases que heredan de MongoMapper:

• Save
• Delete
• FindByKey
• FindByMongoId

Para listas de objetos que hereden de MongoMapper:

• MongoFind

Por alguna razón no esta disponible en el “Centro de Software de Ubuntu” la ultima versión de MonoDevelop, pero eso no quiere decir que no podamos instalarla, podemos bajarnos el código de github compilarlo e instalar la ultima versión en nuestro Ubuntu.

Lo primero que necesitamos es el git instalado en el Ubuntu, abrimos un terminal y:
> sudo apt-get install git-core
> sudo apt-get install git-doc

Después creas una carpeta nueva, te posicionas en ella y descargas la ultima versión del código desde github con:
> git clone https://github.com/mono/monodevelop.git

Ahora ya tenemos el código, antes de seguir hay que ver si tenemos instalado todo lo necesario.

El autoconf y automake:
> sudo apt-get install autoconf
> sudo apt-get install automake

El mono:
> sudo apt-get install mono-complete
> sudo apt-get install mono-gmcs
> sudo apt-get install mono-adddins-utils

Los mono-addins necesarios:
> sudo apt-get install libmono-addins-cil-dev
> sudo apt-get install libmono-addins-gui-cil-dev

librerias de gtc y gnome:
> sudo apt-get install gtk-sharp2
> sudo apt-get install gnome-sharp2

Y esta,que reconozco no se para que es, pero hace falta:
> sudo apt-get install intltool

Con todas las dependencias instaladas te metes en el directorio donde hemos descargado el código y:
>./configure

Cuando termine
>make

y cuanto termine
>sudo make install

y listo ya tienes la ultima versión de MonoDevelop Instalada

En este post os voy a hablar de este framework php llamado CakePHP. Es un framework de desarrollo rápido en PHP. Sigue una estructura de archivos MVC y ORM. Este framework intenta ayudar al desarrollador a escribir menos líneas código. Yo por mi experiencia os puede decir que lo logra y su uso es muy sencillo.

En la actualidad, están por la versión 1.3.14 estable.

A continuación os pondré una lista de sus características.

• Arquitectura Modelo, Vista, Controlador
• Aplicación Scaffolding
• Código generado vía Bake
• Helpers para HTML, Forms, Paginación, Ajax, Javascript, XML, RSS y mas
• Lista de control de acceso y autentificación
• Sencillo pero amplio validador del modelo de datos
• Router para la asignación de URL’s y extensiones handling
• Seguridad, Sesión  y componentes RequestHandler
• Clases para trabajar con Archivos, Carpetas, Arrays y mas
• etc

Una vez descargado el framework observamos 3 carpetas principales:

• app: Es donde se ubicaran los ficheros de tu aplicación.
• cake
• vendors: Aquí es donde meteremos todas las librerías de terceros.

Dentro de la carpeta App encontraremos la siguiente estructura:

• config: Aquí se ubican los pocos archivos de configuración de bases datos, arranque, archivos de configuración del núcleo, etc.
• controllers: Se ubican todos los controladores de tu aplicación.
• locale: Almacena los archivos de recursos de localización (idioma)
• models: Contiene los modelos de tu aplicación.
• plugins: Contiene los paquetes de plugins.
• tmp: Aquí se guarda información temporal.
• vendors: Aquí se guardan librerías o clases de terceros.
• views: Se ubica los archivos de visualización aquí.
• webroot: Esta carpeta es la raíz del sitio. Dentro se ubican css, imagenes y JavaScript.

Bueno hasta aquí he hecho una pequeña introducción. Mas adelante pondré unos ejemplos y algunos consejos.

Saludos

Ahora hay disponibles “Extension Methods” en las las listas de Objetos y en los Objetos que heredan de MongoMapper y se pueden cargar los objetos tipo MyClass.FindByKey(…) o MyClassList.MongoFind(…).

He hecho algunas pruebas viendo lo que tarda de una manera y la otra y no hay prácticamente diferencia, de todas formas eran pruebas preliminares.

El código queda algo mejor sin acceder a los métodos estáticos de la clase base:

List<Country> countries = new List<Country>();

countries.MongoFind(Query.Or(MongoQuery.Eq((Country co) => co.Code, "ES"), MongoQuery.Eq((Country co) => co.Code, "UK")));

Country country = new Country();

country.FindByKey("ES");

Puedes ver algunos ejemplos y las pruebas aquí, cualquier bug o mejora que se te ocurra, fork o mail me

https://github.com/emiliotorrens/MongoMapper.NET

.

Esta clase es la que nos dará toda la información que necesitamos, la encontraremos en el espacio de nombres System.Diagnostics.

Aquí dejo un ejemplo de uso:

var timer = System.Diagnostics.Stopwatch.StartNew();

for (int i = 0; i < 1000000; i++)

{

    //...

}

timer.Stop();

Console.WriteLine(string.Format("Elapsed: {0}", timer.Elapsed));

Console.WriteLine(string.Format("MS: {0}", timer.ElapsedMilliseconds));

Console.WriteLine(string.Format("Ticks: {0}", timer.ElapsedTicks));

Creo que la versión ya esta mas o menos para probar así que toca escribir el changelog de las ultimas modificaciones, las hechas desde que lo movimos de codeplex a github.

Casi todas las modificaciones vienen de refactoring o de necesidades que me he ido encontrando al hacer pruebas con una CRS cambiando el SQL por MongoDB, pero cualquier sugerencia es bienvenida.

Los cambios:

• El id pasa a ser Long, era necesario para poderlo definir como autoincremental, además es mas legible.
• Añadidos extension methods de búsqueda (MongoFind) para las Listas de objetos (que hereden de MongoMapper), puedes ver el código aquí y ejemplos aquí
• Posibilidad de guardar en un campo de la clase base el Documento Original en el momento de Deserializar, de esta manera podemos comprobar cambiosy, en un futuro, hacer rollback.
• Al intentar insertar un documento que ya existe posibilidad de lanzar excepción o de modificar el existente.
• Si no se define MongoKey o se le define vacío usa por defecto el id como PK.
• Parada la opción de pasar expresiones para los filtros, vi que la gente del Driver estaba trabajando en algo igual, así que esperare que lo terminen
• Intento tipar un poco los Querys, puedes crear un Query pasándole el campo en una expresión, tipo: MongoQuery.Eq((Country c) => c.Code, “ES”), puedes ver ejemplos aquí.
• Añadidos metodos de búsqueda que devuelven un cursor, ahora existen los FindAsList y los FindAsCursor, así se pueden usar los SetFields, SetLimit, SetSkip etc ..
• Sección de configuración propia en el config de la aplicación, puedes ver este ejemplo.
• Añadidas mas opciones de configuración:
  • MaxDocumentSize
  • SafeMode
  • FSync
  • ExceptionOnDuplicateKey
  • EnableOriginalObject
  • UseIncrementalId
  • PoolSize
  • WaitQueueTimeout

El tema de usar un id Incremental afecta al rendimiento a la hora de insertar documentos ya que lo que hace es crear una colección donde guarda el ultimo id usado para cada colección y tiene que incrementar en cada insert, puedes ver el código aquí, es configurable el usarlo o no.

Otro tema que afecta al rendimiento es el de guardar el Objeto original, por eso lo puse configurable también, afecta al rendimiento de lectura ya que hace una Serializacion al Deserializar cada documento para guardar una copia en formato JSV, aunque esto no se nota mucho, para Serilizar/Deserializar en el tema del Documento Original utilizo ServiceStack.Text, es lo mas rápido que he encontrado, así que ahora tiene esa dependencia.

En el proyecto de Test puedes ver algunos ejemplos de como usar MongoMapper, agradezco cualquier idea/comentario

https://github.com/emiliotorrens/MongoMapper.NET

.

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<T>(this String str) {return JsonConvert.DeserializeObject<T>(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<MyClass>();

    }

}

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);

}

Esta es la definición “formal” de AOP:

“El principal objetivo de la POA es la separación de las funcionalidades dentro del sistema:

Por un lado funcionalidades comunes utilizadas a lo largo de la aplicación.
Por otro lado, las funcionalidades propias de cada módulo.

Cada funcionalidad común se encapsulará en una entidad.”

Hay varios frameworks que nos ayudan a programar AOP, yo el que estoy usando es “PostSharp” que es para .net, y con este voy a poner un ejemplo en el que logueamos el usuario y la fecha de modificación en todos nuestros objetos implementando un interface y añadiendo un atributo al método Save.

Creamos el interface:

public interface ILogeable

 {

     string LastModificationUser { get; set; }

     DateTime LastModificationDateTime { get; set; }

 }

Luego creamos el atributo, aquí es donde esta el tema, el atributo lo creamos heredando una clase de OnMethodBoundaryAspect, que es una clase de PostSharp, de esa clase luego sobre escribimos los metodos que nos interese, estos metodos son los que se llamaran desde el método de nuestras clases que tengan este atributo, hay 4 metodos a sobre escribir: OnEntry, OnExit, OnSuccess y OnException como parámetro recibimos unos MethodExecutionArgs en los que encontraremos toda la información necesaria.

En este caso solo utilizo el OnEntry

[Serializable()]

public class LogAttribute : OnMethodBoundaryAspect

{

    public override void OnEntry(MethodExecutionArgs args)

    {

        if (typeof(ILogeable).IsAssignableFrom(args.Instance.GetType()))

        {

            ((ILogeable) args.Instance).LastModificationUser = Thread.CurrentPrincipal.Identity.Name;               

            ((ILogeable) args.Instance).LastModificationDateTime = DateTime.Now;

        }

    }        

}

Cualquier clase que implemente el interfaz y le pongamos el atributo en el método que queramos ejecutara este código, por ejemplo:

public class MyClass: ILogeable

{

    public string LastModificationUser { get; set; }

    public DateTime LastModificationDateTime { get; set; }

    [Log]

    public void Save() {}

}

Una de las cosas que me gusta de PostSharp es que no ejecuta por reflection en tiempo de ejecución si no que inyecta código en tus metodos en tiempo de compilación, así que no afecta de manera negativa al performance de la aplicación.

No dejéis de revisar el método “CompileTimeInitialize”, en el podemos usar reflection tranquilamente, ya que se ejecuta en tiempo de compilación, para guardar valores en variables y usarlas luego en tiempo de ejecución, por ejemplo:

public override void CompileTimeInitialize(System.Reflection.MethodBase method, AspectInfo aspectInfo)

{

    string objName = method.DeclaringType.Name;

    string methodName = method.Name;

}

Este es un ejemplo sencillo, las posibilidades son muchísimas, podéis ver muchos ejemplos en la pagina del PostSharp.

Hemos movido el proyecto desde codeplex a github, así no es necesario tener una licencia de Team Explorer ni el Visual Studio para contribuir.

https://github.com/emiliotorrens/MongoMapper.NET

Ahora nos vamos a centrar en el rendimiento y en ver como implementar algún sistema de transacciones, el tema de parseo de expresiones para filtrar de momento queda parado ya que he visto que la gente del Driver esta desarrollando el tema de LINQ, así que esperamos a ver que pasa.

La versión subida es prácticamente la misma que la ultima de codeplex con estas modificaciones:

- Actualizadas las dependencias a la ultima versión del Driver de Mongo
- Re-escrito tema de busquedas, eliminadas algunas opciones inútiles, posibilidad de devolver List o MongoCursor, utiliza QueryComplete como parámetro en vez de clases propias y algunas cosas mas …
- Añadido ITransaction para desarrollar el tema de transacciones
- La búsqueda por expresiones devuelve siempre un NotImplementedException ahora, esta pendiente revisar todo el código