Encuentra y Query Datos de Entidades con LINQ

Datos de muestra

Los ejemplos de esta guía utilizan el planets colección de la base de datos sample_guides. Los documentos en esta colección utilizan la siguiente clase 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 colección es de la conjuntos de datos de muestra proporcionados por Atlas. Consulta la guía Inicio rápido para aprender a crear un clúster gratuito de MongoDB y cargar estos datos de muestra.

Encuentra una entidad individual

El método FirstOrDefault() devuelve la primera entidad que encuentra en tu colección que coincide con los criterios de búsqueda y devuelve null si no se encuentran entidades coincidentes.

El siguiente código utiliza el método FirstOrDefault() para encontrar un planeta en el campo name de “Mercurio” a partir de un DBSet llamado Planets e imprime el nombre del planeta en la consola:

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

Encontrar varios entidades

Puedes utilizar el método Where() para recuperar múltiples entidades de tus colecciones. Where() devuelve todas las entidades que coinciden con los criterios de búsqueda.

El siguiente código usa el método Where() para encontrar todos los planetas que tengan el campo hasRings establecido en true e imprime los nombres de los planetas en la consola.

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

Query a Shadow Property

Una propiedad en la sombra es una propiedad que no está definida en su clase de entidad .NET, pero que está incluida en el modelo de Entity Framework y está mapeada a campos en la base de datos. Puede utilizar las propiedades ocultas para query o rastrear datos en sus documentos sin exponerlo como una propiedad en su entidad.

Para hacer referencia a una propiedad sombra en una query LINQ, llama al método EF.Property<T>() y pasa el nombre de la propiedad configurada como argumento. El argumento de tipo genérico debe coincidir con el tipo de datos de la propiedad shadow.

Por ejemplo, la clase Planet no define una propiedad para el campo mainAtmosphere. Para configurar este campo como una propiedad sombra, llame al método Property<T>() en el método OnModelCreating() de PlanetDbContext, como se muestra en el siguiente ejemplo:

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");
    }
}

La llamada a modelBuilder.Entity<Planet>().Property<string[]>("mainAtmosphere") le indica al framework que incluya mainAtmosphere en el modelo y lo asigne a un campo string[] en MongoDB.

El siguiente código utiliza el método EF.Property<string[]>() para encontrar todos los planetas que tienen una propiedad de sombra mainAtmosphere no vacía y imprime los nombres de los planetas en la consola:

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

Limitar el número de resultados

Utilice el método Take() para especificar un número máximo de entidades que se devolverán en una consulta.

El siguiente código utiliza el método Take() para devolver los primeros 3 planetas de la colección Planets:

var planetList = db.Planets.Take(3);
foreach (var p in planetList)
{
    Console.WriteLine(p.name);
}

Omitir resultados

Utilice el método Skip() para especificar una cantidad de entidades que se deben omitir antes de devolver los resultados de una consulta.

El siguiente código utiliza los métodos OrderBy() y Skip() para omitir los primeros 5 planetas (ordenados por orderFromSun) y devolver los planetas restantes:

var planetList = db.Planets.OrderBy(p => p.orderFromSun).Skip(5);
foreach (var p in planetList)
{
    Console.WriteLine(p.name);
}

count

El siguiente ejemplo utiliza el método Count() para contar el número de elementos en la colección Planets:

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

El siguiente ejemplo utiliza el método Count() para contar el número de elementos en la colección Planets que tienen un campo hasRings configurado en true:

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

LongCount

El siguiente ejemplo utiliza el método LongCount() para contar el número de elementos en la colección Planets y devuelve el resultado como un long:

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

El siguiente ejemplo usa el método LongCount() para contar el número de elementos en la colección Planets que tienen el campo hasRings configurado en true y devuelve el resultado como un long:

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

Any

El siguiente ejemplo utiliza el método Any() para comprobar si algún elemento de la colección Planets tiene el campo hasRings configurado en true:

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

máximo

El siguiente ejemplo utiliza el método Max() para encontrar el valor máximo del campo orderFromSun en la colección Planets:

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

Min

El siguiente ejemplo utiliza el método Min() para encontrar el valor mínimo del campo orderFromSun en la colección Planets:

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

Suma

El siguiente ejemplo utiliza el método Sum() para encontrar la suma del campo orderFromSun en la colección Planets:

var totalOrderFromSun = db.Planets.Sum(p => p.orderFromSun);
Console.WriteLine("Total Order From Sun: " + totalOrderFromSun);

Media

El siguiente ejemplo utiliza el método Average() para encontrar el valor promedio del campo orderFromSun en la colección Planets:

var averageOrderFromSun = db.Planets.Average(p => p.orderFromSun);
Console.WriteLine("Average Order From Sun: " + averageOrderFromSun);

Habilitar el registro de datos confidenciales

El proveedor registra el texto completo de la consulta MQL solo cuando el registro de datos confidenciales está habilitado. Si no habilita el registro de datos confidenciales, los registros de consulta podrían omitir valores. Para habilitar el registro de datos confidenciales, llame al método EnableSensitiveDataLogging() desde su DbContextOptionsBuilder objeto, como se muestra en el siguiente ejemplo:

var mongoClient = new MongoClient("<connection string URI>");
var dbContextOptions =
    new DbContextOptionsBuilder<MyDbContext>()
        .UseMongoDB(mongoClient, "<database name>")
        .LogTo(Console.WriteLine)
        .EnableSensitiveDataLogging()
        .Options;
var db = new MyDbContext(dbContextOptions);

Convenciones de serialización personalizadas

Si registra convenciones de serialización BSON personalizadas en MongoClient, como la nomenclatura de campos en formato camel case, dichas convenciones pueden modificar los nombres de los campos almacenados en MongoDB, de modo que difieran de los nombres de las propiedades en su modelo de entidad. El proveedor de EF Core utiliza los nombres de las propiedades de la entidad para generar MQL, por lo que una discrepancia puede provocar que las consultas se dirijan a campos incorrectos y omitan cualquier índice en esos campos. Cuando los nombres de los campos almacenados difieren de los nombres de las propiedades de la entidad, puede asignar explícitamente una propiedad a su nombre de campo almacenado en OnModelCreating() mediante HasElementName(), como se muestra en el siguiente ejemplo:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);
    modelBuilder.Entity<Planet>()
        .Property(p => p.name)
        .HasElementName("name");
}