Relacionamentos incorporados e referências manuais

Visão geral

Neste guia, você pode aprender como usar o MongoDB Entity Framework Core Provider para modelar relacionamentos entre documentos em seu banco de dados MongoDB . O fornecedor do EF Core oferece suporte aos seguintes tipos de relacionamento :

• Relacionamentos incorporados: subdocumentos incorporados diretamente em um documento pai. Essa é a abordagem recomendada para relacionamentos um-para-um e um-para-muitos no MongoDB.

• Referências manuais: um documento que faz referência a outro documento armazenando sua ID em um campo, em vez de incorporar o documento como um subdocumento. Essa abordagem funciona bem para modelar relacionamentos de muitos para muitos ou quando você precisa acessar os documentos de forma independente.

Relacionamentos incorporados

Para incorporar um subdocumento em um documento pai, especifique o modelo para o documento incorporado como uma entidade própria. Os relacionamentos incorporados são a maneira nativa do MongoDB de modelar relacionamentos e oferecer melhor desempenho para documentos que você acessa com frequência juntos.

Você pode designar uma entidade própria das seguintes maneiras:

• Atributo [Owned]: Aplique o [Owned] atributo de anotação de dados à classe de modelo do subdocumento. Essa abordagem é declarativa e concisa, mas também menos flexível, porque se aplica globalmente a todos os usos do tipo próprio.

• API fluente: Chame OwnsOne() os OwnsMany() métodos ou na sua DbContext configuração do. Essa abordagem oferece mais controle e flexibilidade, permitindo que você configure o relacionamento de forma diferente para entidades específicas sem modificar a classe do modelo.

As seções a seguir fornecem exemplos dessas abordagens para modelar entidades de propriedade única e múltipla.

[Owned]
public class Address
{
    public string Street { get; set; } = null!;
    public string City { get; set; } = null!;
    public string Country { get; set; } = null!;
}
public class Customer
{
    public ObjectId Id { get; set; }
    public string Name { get; set; } = null!;
    public Address Address { get; set; } = null!;
}

public class CustomerDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; } = null!;
    public CustomerDbContext(DbContextOptions options) : base(options) { }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Customer>(c =>
        {
            c.OwnsOne(c => c.Address);
            c.ToCollection("customers");
        });
    }
}

{
  "_id": ObjectId("..."),
  "Name": "John Doe",
  "Address": {
    "Street": "123 Main St",
    "City": "New York",
    "Country": "USA"
  }
}

[Owned]
public class Order
{
    public string Product { get; set; } = null!;
    public int Quantity { get; set; }
}
public class CustomerWithOrders
{
    public ObjectId Id { get; set; }
    public string Name { get; set; } = null!;
    public List<Order> Orders { get; set; } = new();
}

public class OrderDbContext : DbContext
{
    public DbSet<CustomerWithOrders> Customers { get; set; } = null!;
    public OrderDbContext(DbContextOptions options) : base(options) { }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<CustomerWithOrders>(c =>
        {
            c.OwnsMany(c => c.Orders);
            c.ToCollection("customers");
        });
    }
}

{
  "_id": ObjectId("..."),
  "Name": "Jane Smith",
  "Orders": [
    { "Product": "Laptop", "Quantity": 1 },
    { "Product": "Mouse", "Quantity": 2 }
  ]
}

Referências manuais

Para modelar relacionamentos entre entidades que não são incorporadas, você pode armazenar referências manualmente salvando a ID de um documento em um campo de outro documento. Essa abordagem exige que você gerencie o relacionamento no código do aplicação .

O exemplo a seguir mostra como armazenar uma referência a uma entidade relacionada:

public class Author
{
    public ObjectId Id { get; set; }
    public string Name { get; set; } = null!;
}
public class Book
{
    public ObjectId Id { get; set; }
    public string Title { get; set; } = null!;
    // Store reference to Author by storing the Author's Id
    public ObjectId AuthorId { get; set; }
}

Para recuperar a entidade relacionada, você deve consultar a coleção referenciada separadamente, como mostrado no exemplo a seguir:

// Query a book and its author
var book = db.Books.FirstOrDefault(b => b.Title == "My Book");
var author = db.Authors.FirstOrDefault(a => a.Id == book!.AuthorId);

Informações adicionais

Para saber mais sobre modelagem de dados no MongoDB, consulte Modelagem de Dados na documentação do MongoDB Server .

Para saber mais sobre os tipos de entidades próprias no Entity Framework Core, consulte Tipos de entidades próprias na documentação do Microsoft Entity Framework Core.