Mapeo de clases

Overview

En esta guía, puedes aprender cómo personalizar la manera en que el controlador MongoDB .NET/C# mapea documentos BSON hacia y desde clases C#. Lee esta página para obtener más información sobre el comportamiento de mapeo de clase por defecto, o si debes personalizar la manera en que el driver serializa o deserializa tus datos.

También puedes usar atributos POCO para configurar el comportamiento de la serialización. Para obtener más información, consulta el POCOs guide.

Mapeo automático de clases

Cuando utilizas una clase, en lugar de un(a) BsonDocumentPara representar datos en una colección de MongoDB, el controlador .NET/C# crea automáticamente un mapa de clases que se utiliza para serializar o deserializar los datos. Se realiza este mapeo haciendo coincidir el nombre del campo en el documento con el nombre de la propiedad en la clase.

Creación manual de un mapa de clase

Puedes omitir la funcionalidad de asignación de clases automática del driver y definir manualmente el mapa de clases utilizando el método RegisterClassMap().

El siguiente ejemplo define una clase de Person:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
}

El siguiente código demuestra cómo registrar el mapa de clases para la clase Person:

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
    classMap.MapMember(p => p.Name);
    classMap.MapMember(p => p.Age);
    classMap.MapMember(p => p.Hobbies);
});

También puede asignar manualmente un subconjunto de propiedades de la clase, mientras permite que el controlador asigne automáticamente las propiedades restantes. Para hacer esto, registre un mapa de clases y llame al método AutoMap() antes de especificar manualmente sus propiedades.

En el siguiente ejemplo de código, el método AutoMap() asigna todas las propiedades de la clase Person y luego ajusta manualmente la asignación para el campo Hobbies:

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
    classMap.AutoMap();
    classMap.MapMember(p => p.Hobbies).SetElementName("favorite_hobbies");
});

Personalizar la serialización de clases

Puedes personalizar la forma en que el driver serializa y deserializa documentos a nivel de clase aplicando atributos a la clase o llamando métodos al registrar un mapa de clase.

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.UnmapMember(p => p.Age);
});

[BsonIgnoreExtraElements]
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
}

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.SetIgnoreExtraElements(true);
});

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.MapIdMember(p => p.Identifier);
});

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
});

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.MapIdMember(p => p.Identifier).SetIdGenerator(StringObjectIdGenerator.Instance);
});

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
     classMap.AutoMap();
     classMap.IdMemberMap.SetSerializer(new GuidSerializer(GuidRepresentation.Standard));
});

Mapeo con constructores

Por defecto, el .NET/C# Driver solo puede mapear automáticamente una clase si esta tiene un constructor sin argumentos. Si deseas que el controlador use un constructor que acepte uno o más argumentos, puedes añadir el atributo BsonConstructor al constructor. En este caso, el driver examina los tipos para determinar cómo asignar los argumentos del constructor a las propiedades o campos de la clase.

Cuando el driver crea un mapa de clase para la siguiente clase Person, utilizará el constructor marcado con el atributo BsonConstructor. El argumento name se asignará a la propiedad Name y el argumento age se asignará a la propiedad Age.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
    [BsonConstructor]
    public Person(string name, string age)
    {
        Name = name;
        Age = age;
    }
}

También puede especificar el constructor que se utilizará cuando registre su mapa de clases:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
    public Person(string name, string age)
    {
        Name = name;
        Age = age;
    }
}
BsonClassMap.RegisterClassMap<Person>(classMap =>
{
    classMap.AutoMap();
    classMap.MapCreator(p => new Person(p.Name, p.Age));
});

Personalizar la serialización de propiedades

Se puede personalizar cómo el controlador serializa una propiedad de clase añadiendo atributos a la propiedad. Para obtener más información sobre la serialización de propiedades personalizadas, consulta Serialización personalizada.

public class Person
{
    public string Name { get; set;
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
    [BsonExtraElements]
    public BsonDocument ExtraElements {get; set;}
}

BsonClassMap.RegisterClassMap<Person>(classMap =>
{
    classMap.AutoMap();
    classMap.MapExtraElementsMember(p => p.ExtraElements);
});

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies {get; set;}
    public bool ShouldSerializeAge()
    {
       return Age != 0;
    }
}

BsonClassMap.RegisterClassMap<Employee>(classMap =>
{
    classMap.AutoMap();
    classMap.MapMember(p => c.Age).SetShouldSerializeMethod(
        obj => ((Person) obj).Age != 0
    );
});

Información Adicional

Para más información sobre el uso de clases C#, consulta POCOs.

Documentación de la API

• Mapa de clases de Bson

• RegisterClassMap

• AutoMap