Mapeo de clases

Overview

En esta guía, aprenderá a personalizar la forma en que el controlador MongoDB .NET/C# asigna documentos BSON a y desde clases de C#. Lea esta página para obtener más información sobre el comportamiento predeterminado de asignación de clases o si necesita personalizar la forma en que el controlador serializa o deserializa sus datos.

También puede usar atributos POCO para configurar el comportamiento de serialización. Para obtener más información, consulte Guíade POCO.

Mapeo automático de clases

Cuando se utiliza una clase, en lugar de una BsonDocumentPara representar datos en una colección de MongoDB, el controlador .NET/C# crea automáticamente un mapa de clases que utiliza para serializar o deserializar los datos. Esta asignación se realiza 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 clases

Puede omitir la funcionalidad de mapeo automático de clases del controlador y definir manualmente el mapa de clases utilizando el método RegisterClassMap().

El siguiente ejemplo define una clase 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 clase 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 clase, permitiendo que el controlador asigne automáticamente las propiedades restantes. Para ello, registre un mapa de clase y llame al método AutoMap() antes de especificar manualmente las 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

Puede personalizar cómo el controlador serializa y deserializa documentos a nivel de clase aplicando atributos a la clase o llamando métodos mientras registra 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

De forma predeterminada, el controlador .NET/C# solo puede asignar automáticamente una clase si esta tiene un constructor sin argumentos. Si desea que el controlador utilice un constructor que acepte uno o más argumentos, puede agregarle el atributo BsonConstructor. En este caso, el controlador examina los tipos para determinar cómo asignar los argumentos del constructor a las propiedades o campos de la clase.

Cuando el controlador 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 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 a utilizar al registrar su mapa de clase:

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 obtener más información sobre el uso de clases C#, consulte POCO.

Documentación de la API

• Mapa de clases de Bson

• RegistrarMapaDeClase

• AutoMap