Localizar e query dados de entidade com LINQ

Dados de amostra

Os exemplos nesta guia usam a coleção planets do banco de dados do sample_guides . Os documentos nesta coleção utilizam a seguinte classe Planet como modelo:

public class Planet
{
    public ObjectId _id { get; set; }
    public string name { get; set; } = null!;
    public int orderFromSun { get; set; }
    public bool hasRings { get; set; }
}

Esta coleção é dos conjuntos de dados de amostra fornecidos pelo Atlas. Consulte o guia Início rápido para saber como criar um cluster MongoDB gratuito e carregar esses dados de amostra.

Encontre uma única entidade

O método FirstOrDefault() retorna a primeira entidade que encontra na sua collection que corresponda aos critérios de pesquisa e retorna null se nenhuma entidade correspondente for encontrada.

O código a seguir usa o método FirstOrDefault() para localizar um planeta com o campo name de "Mercury" de um DBSet chamado Planets e imprime o nome do planeta no console:

var planet = db.Planets.FirstOrDefault(p => p.name == "Mercury");
Console.WriteLine(planet?.name);

Encontrar múltiplas entidades

Você pode utilizar o método Where() para recuperar múltiplas entidades de sua collection. Where() retorna todas as entidades que correspondem aos critérios de pesquisa.

O código a seguir usa o método Where() para encontrar todos os planetas que têm o campo hasRings definido como true e imprime os nomes dos planetas no console.

var planets = db.Planets.Where(p => p.hasRings);
foreach (var p in planets)
{
    Console.WriteLine(p.name);
}

Executar query de uma propriedade de sombra

Uma propriedade shadow é uma propriedade que não está definida em sua classe de entidade .NET, mas está incluída no modelo Entity Framework e mapeada para campos no banco de dados. Você pode usar propriedades de sombra para query ou acompanhar dados em seus documentos sem expô-los como uma propriedade em sua entidade.

Para fazer referência a uma propriedade de sombra em uma query LINQ, chame o método EF.Property<T>() e passe o nome da propriedade configurada como um argumento. O argumento de tipo genérico deve corresponder ao tipo de dados da propriedade shadow .

Por exemplo, a classe Planet não define uma propriedade para o campo mainAtmosphere. Para configurar este campo como uma propriedade de sombra, chame o método Property<T>() no método OnModelCreating() de PlanetDbContext, como mostrado no seguinte exemplo:

public class PlanetDbContext : DbContext
{
    public DbSet<Planet> Planets { get; init; } = null!;
    public static PlanetDbContext Create(IMongoDatabase database) =>
        new(new DbContextOptionsBuilder<PlanetDbContext>()
            .UseMongoDB(database.Client, database.DatabaseNamespace.DatabaseName)
            .Options);
    public PlanetDbContext(DbContextOptions options)
        : base(options)
    {
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Planet>().ToCollection("planets");
        modelBuilder.Entity<Planet>().Property<string[]>("mainAtmosphere");
    }
}

A chamada para modelBuilder.Entity<Planet>().Property<string[]>("mainAtmosphere") instrui a framework a incluir mainAtmosphere no modelo e mapeá-lo para um campo string[] no MongoDB.

O código a seguir usa o método EF.Property<string[]>() para localizar todos os planetas que têm uma propriedade shadow mainAtmosphere não vazia e imprime os nomes dos planetas no console:

var planets = db.Planets.Where(
    p => EF.Property<string[]>(p, "mainAtmosphere").Length > 0);
foreach (var p in planets)
{
    Console.WriteLine(p.name);
}

Mql.Exists

O método Mql.Exists() combina documentos que contêm o campo especificado, incluindo documentos em que o valor de campo é null.

O código a seguir usa o método Mql.Exists() para encontrar todos os planetas que têm o campo hasRings e imprime os nomes dos planetas no console:

var planetNames = db.Planets
    .Where(p => Mql.Exists(p.hasRings))
    .Select(p => p.name);
foreach (var name in planetNames)
{
    Console.WriteLine(name);
}

Mql.IsMissing

O método Mql.IsMissing() corresponde a documentos que não contêm o campo especificado.

O código a seguir usa o método Mql.IsMissing() para encontrar todos os planetas que não têm o campo hasRings e imprime os nomes dos planetas no console:

var planetNames = db.Planets
    .Where(p => Mql.IsMissing(p.hasRings))
    .Select(p => p.name);
foreach (var name in planetNames)
{
    Console.WriteLine(name);
}

Mql.IsNullOrMissing

O método Mql.IsNullOrMissing() corresponde a documentos em que o campo especificado está ausente ou tem um valor null.

O código a seguir usa o método Mql.IsNullOrMissing() para encontrar todos os planetas onde o campo hasRings está ausente ou null e imprime os nomes dos planetas no console:

var planetNames = db.Planets
    .Where(p => Mql.IsNullOrMissing(p.hasRings))
    .Select(p => p.name);
foreach (var name in planetNames)
{
    Console.WriteLine(name);
}