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; }
    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; }
    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 estrutura 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 planets = db.Planets.Where(p => Mql.Exists(p.hasRings));
foreach (var p in planets)
{
    Console.WriteLine(p.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 planets = db.Planets.Where(p => Mql.IsMissing(p.hasRings));
foreach (var p in planets)
{
    Console.WriteLine(p.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 planets = db.Planets.Where(p => Mql.IsNullOrMissing(p.hasRings));
foreach (var p in planets)
{
    Console.WriteLine(p.name);
}

Contar

O exemplo seguinte utiliza o método Count() para contar o número de elementos na collection Planets:

var planetCount = db.Planets.Count();
Console.WriteLine("Planet Count: " + planetCount);

O exemplo seguinte utiliza o método Count() para contar o número de elementos na coleção Planets que têm um campo hasRings configurado para true:

var planetCountWithRings = db.Planets.Count(p => p.hasRings);
Console.WriteLine("Planet Count with Rings: " + planetCountWithRings);

LongCount

O exemplo seguinte utiliza o método LongCount() para contar o número de elementos na coleção Planets e retorna o resultado como um long:

var planetCountLong = db.Planets.LongCount();
Console.WriteLine("Long Planet Count: " + longCount);

O exemplo seguinte utiliza o método LongCount() para contar o número de elementos na coleção Planets que têm um campo hasRings configurado para true e retorna o resultado como long:

var planetCountLongWithRings = db.Planets.LongCount(p => p.hasRings);
Console.WriteLine("Long Planet Count with Rings: " + planetCountLongWithRings);

Any

O exemplo seguinte utiliza o método Any() para verificar se algum elemento na coleção Planets tem um campo hasRings configurado para true:

var results = db.Planets.Any(p => p.hasRings);
foreach (var p in results)
{
    Console.WriteLine("Planet with Rings: " + p.name);
}

Máx

O exemplo seguinte utiliza o método Max() para localizar o valor máximo do campo orderFromSun na collection Planets:

var furthestPlanet = db.Planets.Max(p => p.orderFromSun);
Console.WriteLine("Furthest Planet: " + furthestPlanet.name);

Min

O exemplo seguinte utiliza o método Min() para localizar o valor mínimo do campo orderFromSun na collection Planets:

var closestPlanet = db.Planets.Min(p => p.OrderFromSun);
Console.WriteLine("Closest Planet: " + closestPlanet.Name);

Soma

O exemplo a seguir utiliza o método Sum() para localizar a soma do campo mass na coleção Planets:

var totalMass = db.Planets.Sum(p => p.mass);
Console.WriteLine("Total Mass of Planets: " + totalMass);

Média

O exemplo seguinte utiliza o método Average() para localizar o valor médio do campo mass na collection Planets:

var averageMass = db.Planets.Average(p => p.mass);
Console.WriteLine("Average Mass of Planets: " + averageMass);