He subido una nueva versión a master con algunos cambios interesantes:

• Si esta configurado el SafeMode devuelve la excepción que devuelve el servidor en las operaciones de escritura
• Se puede definir IdGenerator, incremental o ObjectId, a las listas de clases contenidas en las clases que heredan de MongoMapper. Para eso hay que:
  • Heredar la clase contenida de MongoMapperChild
  • Marcar la propiedad que es colección con el atributo MongoChildCollection
• Se puede definir si los Id (tanto los de MongoMapper como los de las clases embebidas) son incrementales en el App.config o con el atributo MongoMapperIdIncrementable de la clase.

Aquí dejo un ejemplo de como definir las clases:

    public class Child: MongoMapperChild
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public DateTime BirthDate { get; set; }
        public string Country { get; set; }
    }
 
    [MongoKey(KeyFields = "")]
    [MongoIndex(IndexFields = "ID,Country")]
    [MongoIndex(IndexFields =  "Name")]
    [MongoMapperIdIncrementable(IncremenalId = true, ChildsIncremenalId = true)]
    public class Person : MongoMapper
    {
        public Person()
        {
            Childs = new List<Child>();
        }
 
        public string Name { get; set; }
        public int Age { get; set; }
        public DateTime BirthDate { get; set; }
        public bool Married { get; set; }
        public decimal BankBalance { get; set; }
        public string Country { get; set; }
 
        [MongoChildCollection]
	public List<Child> Childs { get; set;}
    }

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

He subido una versión a master con el tema de los extension methods terminado.

Un código que era:

Country c = new Country {Code ="US", Name = "Estados Unidos"};
c.Save<Country>();
 
Country c2 = Country.FindByKey<Country>("US");
 
List<Country> 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<Country> Countries = new List<Country>();
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

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

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