/ /

Actualizar muchos documentos

Docs Home

/ /

Driver C#/.NET

Actualizar muchos documentos

Docs Home

Librerías de clientes

Driver C#/.NET

Actualizar muchos documentos

Actualizar arreglos en muchos documentos

Overview

En esta página, puedes aprender a crear UpdateDefinition objetos para campos de arreglo. Un objeto UpdateDefinition especifica el tipo de operación de actualización que se debe realizar, los campos que se deben actualizar y el nuevo valor para cada campo, si corresponde.

El driver .NET/C# admite los operadores y modificadores de actualización de arreglos descritos en la Manual del Servidor de MongoDB. Para crear un objeto UpdateDefinition para uno de estos operadores, llama al método correspondiente de la propiedad Builders.Update. Las siguientes secciones describen estos métodos con más detalle.

Después de crear un objeto UpdateDefinition, pásalo al método UpdateMany() o UpdateManyAsync(). Para obtener más información sobre estos métodos, consulta el Página Actualizar muchos.

Nota

Sobrecargas de métodos

Muchos de los métodos en esta página tienen varias sobrecargas. Los ejemplos de esta guía muestran solo una definición de cada método. Para obtener más información sobre las sobrecargas disponibles, se puede consultar la documentación de la API.

Datos de muestra

Los ejemplos de esta guía utilizan la colección restaurants de la base de datos sample_restaurants. Los documentos de esta colección utilizan las siguientes clases Restaurant, Address y GradeEntry como modelos:

public class Restaurant
{
    public ObjectId Id { get; set; }
    public string Name { get; set; }
    [BsonElement("restaurant_id")]
    public string RestaurantId { get; set; }
    public string Cuisine { get; set; }
    public Address Address { get; set; }
    public string Borough { get; set; }
    public List<GradeEntry> Grades { get; set; }
}

public class Address
{
    public string Building { get; set; }
    [BsonElement("coord")]
    public double[] Coordinates { get; set; }
    public string Street { get; set; }
    [BsonElement("zipcode")]
    public string ZipCode { get; set; }
}

public class GradeEntry
{
    public DateTime Date { get; set; }
    public string Grade { get; set; }
    public float? Score { get; set; }
}

Nota

Los documentos de la colección restaurants utilizan la convención de nomenclatura snake-case. Los ejemplos de esta guía utilizan un ConventionPack para deserializar los campos de la colección en notación Pascal y asignarlos a las propiedades de la clase Restaurant.

Para aprender más sobre la serialización personalizada, consultar Serialización personalizada.

Esta colección es de los conjuntos de datos de muestra proporcionados por Atlas. Consulte Primeros pasos con el controlador .NET/C# para aprender a crear un clúster gratuito de MongoDB y cargar estos datos de muestra.

Añadir un valor

Para agregar un valor al final de un arreglo, llama al método Builders.Update.Push(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo de arreglo al que agregar un valor. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`value`	El valor que se debe agregar al final del campo de arreglo. Tipo de dato: `TItem`

El siguiente ejemplo de código utiliza el método Push() para añadir un nuevo objeto GradeEntry al arreglo Grades en todos los documentos coincidentes:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .Push(restaurant => restaurant.Grades, new GradeEntry()
    {
        Date = DateTime.Now,
        Grade = "A",
        Score = 96
    });
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .Push(restaurant => restaurant.Grades, new GradeEntry()
    {
        Date = DateTime.Now,
        Grade = "A",
        Score = 96
    });
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Tip

Configurar la operación de push

Para agregar un valor en una posición específica de un arreglo, o para ordenar o cortar el arreglo después de actualizarlo, se debe llamar al método PushEach() en su lugar.

Para agregar un valor al final de un arreglo, pero solo si aún no existe en el arreglo, llame al método Builders.Update.AddToSet(). El MongoDB Server determina si el valor ya existe en el arreglo comparando la representación BSON del valor con la representación BSON de cada otro elemento en el arreglo.

El método AddToSet() acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo de arreglo al que agregar un valor. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`value`	El valor que se debe agregar al final del campo de arreglo. Tipo de dato: `TItem`

El siguiente ejemplo de código llama al método AddToSet() para volver a añadir el primer objeto GradeEntry al arreglo Grades en todos los documentos coincidentes. Dado que el valor ya existe en el arreglo, la operación de actualización no hace nada.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var firstGradeEntry = _restaurantsCollection.Find(filter).FirstOrDefault().Grades[0];
var update = Builders<Restaurant>.Update
    .AddToSet(restaurant => restaurant.Grades, firstGradeEntry);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var firstGradeEntry = _restaurantsCollection.Find(filter).FirstOrDefault().Grades[0];
var update = Builders<Restaurant>.Update
    .AddToSet(restaurant => restaurant.Grades, firstGradeEntry);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Agregar múltiples valores

Para agregar múltiples valores a un arreglo, llama al método Builders.Update.PushEach(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo de arreglo al que se agregarán uno o más valores. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`values`	Los valores a añadir al campo de arreglo. Tipo de dato: `IEnumerable<TItem>`
`slice`	El número de elementos a mantener en el arreglo, contados desde el inicio del arreglo después de las actualizaciones. Si el valor es negativo, el método mantiene el número especificado de elementos desde el final del arreglo. Tipo de dato: `int?`
`position`	La posición en el arreglo en la que se deben añadir los valores. Por defecto, el método agrega los valores al final del arreglo. Tipo de dato: `int?`
`sort`	Un `SortDefinition` objeto que especifica cómo el driver ordena los elementos del arreglo después de agregar los nuevos valores. Tipo de dato: SortDefinition<TItem>

El siguiente ejemplo de código utiliza el método PushEach() para añadir dos nuevos objetos GradeEntry al inicio del arreglo Grades en todos los documentos coincidentes. Luego, se ordenan los elementos del arreglo en orden descendente según los valores de sus campos Score.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.Now, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.Now, Grade = "B+", Score = 89,}
};
var scoreSort = Builders<GradeEntry>.Sort.Descending(g => g.Score);
var update = Builders<Restaurant>.Update.PushEach(
    "Grades",
    newGrades,
    position: 0,
    sort: scoreSort);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.Now, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.Now, Grade = "B+", Score = 89,}
};
var scoreSort = Builders<GradeEntry>.Sort.Descending(g => g.Score);
var update = Builders<Restaurant>.Update.PushEach(
    "Grades",
    newGrades,
    position: 0,
    sort: scoreSort);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Para agregar varios valores a un arreglo, pero solo si aún no existen en el arreglo, llama al método Builders.Update.AddToSetEach(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo de arreglo al que se agregarán uno o más valores. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`values`	Los valores a añadir al campo de arreglo. Tipo de dato: `IEnumerable<TItem>`

El siguiente ejemplo de código llama al método AddToSetEach() para volver a añadir los objetos GradeEntry primero y segundo al arreglo Grades en todos los documentos coincidentes. Como estos valores ya existen en el arreglo, la operación de actualización no realiza ninguna acción.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var doc = _restaurantsCollection.Find(filter).FirstOrDefault();
var firstGradeEntries = new List<GradeEntry> { doc.Grades[0], doc.Grades[1] };
var update = Builders<Restaurant>.Update
    .AddToSetEach(restaurant => restaurant.Grades, firstGradeEntries);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var doc = _restaurantsCollection.Find(filter).FirstOrDefault();
var firstGradeEntries = new List<GradeEntry> { doc.Grades[0], doc.Grades[1] };
var update = Builders<Restaurant>.Update
    .AddToSetEach(restaurant => restaurant.Grades, firstGradeEntries);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Remove Values

Las siguientes secciones explican cómo remover valores de un campo de arreglo.

Primer valor

Para remover el primer valor de un arreglo, llama al método Builders.Update.PopFirst(). Este método acepta el siguiente parámetro:

Parameter	Descripción
`field`	Una expresión que especifica el campo de arreglo desde el cual remover el primer valor. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`

El siguiente ejemplo de código utiliza el método PopFirst() para remover el primer objeto GradeEntry del arreglo Grades en todos los documentos coincidentes:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .PopFirst(restaurant => restaurant.Grades);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .PopFirst(restaurant => restaurant.Grades);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Último valor

Para remover el último valor de un arreglo, llama el método Builders.Update.PopLast(): Este método acepta el siguiente parámetro:

Parameter	Descripción
`field`	Una expresión que especifica el campo del arreglo del cual se removerá el último valor. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`

El siguiente ejemplo de código utiliza el método PopLast() para remover el último objeto GradeEntry del arreglo Grades en todos los documentos coincidentes:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .PopLast(restaurant => restaurant.Grades);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var update = Builders<Restaurant>.Update
    .PopLast(restaurant => restaurant.Grades);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Todos los Instancias de un valor

Para remover todas las instancias de un valor específico de un arreglo, llama al método Builders.Update.Pull(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo del arreglo para remover los valores de. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`value`	El valor que se removerá del campo de arreglo. Tipo de dato: `TItem`

El siguiente ejemplo de código utiliza el método Pull() para eliminar todas las instancias de un objeto GradeEntry específico del arreglo Grades en todos los documentos coincidentes:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add duplicate values to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
_restaurantsCollection.UpdateMany(filter, addUpdate);
// Remove duplicates from Grades array
var pullUpdate = Builders<Restaurant>.Update
    .Pull(restaurant => restaurant.Grades, newGrades[0]);
var result = _restaurantsCollection.UpdateMany(filter, pullUpdate);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add duplicate values to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
await _restaurantsCollection.UpdateManyAsync(filter, addUpdate);
// Remove duplicates from Grades array
var pullUpdate = Builders<Restaurant>.Update
    .Pull(restaurant => restaurant.Grades, newGrades[0]);
var result = await _restaurantsCollection.UpdateManyAsync(filter, pullUpdate);
return result;

Todas las instancias de valores múltiples

Para remover todas las instancias de más de un valor específico de un arreglo, llamar el método Builders.Update.PullAll(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo del arreglo para remover los valores de. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`values`	Los valores a remover del campo de arreglo. Tipo de dato: `IEnumerable<TItem>`

El siguiente ejemplo de código usa el método PullAll() para remover todas las instancias de dos objetos específicos GradeEntry del arreglo Grades en todos los documentos coincidentes:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add duplicate values to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95,},
    new GradeEntry { Date = DateTime.MinValue, Grade = "B", Score = 85 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "B", Score = 85,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
_restaurantsCollection.UpdateMany(filter, addUpdate);
// Remove duplicates from Grades array
var gradesToRemove = new List<GradeEntry> { newGrades[0], newGrades[2] };
var pullUpdate = Builders<Restaurant>.Update
    .PullAll(restaurant => restaurant.Grades, gradesToRemove);
var result = _restaurantsCollection.UpdateMany(filter, pullUpdate);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add duplicate values to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "A", Score = 95,},
    new GradeEntry { Date = DateTime.MinValue, Grade = "B", Score = 85 },
    new GradeEntry { Date = DateTime.MinValue, Grade = "B", Score = 85,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
await _restaurantsCollection.UpdateManyAsync(filter, addUpdate);
// Remove duplicates from Grades array
var gradesToRemove = new List<GradeEntry> { newGrades[0], newGrades[2] };
var pullUpdate = Builders<Restaurant>.Update
    .PullAll(restaurant => restaurant.Grades, gradesToRemove);
var result = await _restaurantsCollection.UpdateManyAsync(filter, pullUpdate);
return result;

Todos los valores que cumplen una condición

Para remover todos los valores que cumplan una condición específica de un arreglo, llama al método Builders.Update.PullFilter(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo del arreglo para remover los valores de. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`filter`	Un filtro de query que especifica la condición para los valores que se deben remover. Tipo de dato: FilterDefinition<TItem>

El siguiente ejemplo de código usa el método PullFilter() para remover todos los objetos GradeEntry donde el valor Grade es "F" del arreglo Grades en los documentos que coinciden:

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add GradeEntry values with "Grade = F" to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 10 },
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 21,},
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 47 },
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 6,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
_restaurantsCollection.UpdateMany(filter, addUpdate);
// Remove all "Grade = F" values from Grades array
var pullUpdate = Builders<Restaurant>.Update
    .PullFilter(restaurant => restaurant.Grades, gradeEntry => gradeEntry.Grade == "F");
var result = _restaurantsCollection.UpdateMany(filter, pullUpdate);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Add GradeEntry values with "Grade = F" to Grades array
var newGrades = new List<GradeEntry>
{
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 10 },
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 21,},
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 47 },
    new GradeEntry { Date = DateTime.Now, Grade = "F", Score = 6,}
};
var addUpdate = Builders<Restaurant>.Update
    .PushEach("Grades", newGrades);
await _restaurantsCollection.UpdateManyAsync(filter, addUpdate);
// Remove all "Grade = F" values from Grades array
var pullUpdate = Builders<Restaurant>.Update
    .PullFilter(restaurant => restaurant.Grades, gradeEntry => gradeEntry.Grade == "F");
var result = await _restaurantsCollection.UpdateManyAsync(filter, pullUpdate);
return result;

Actualizar valores coincidentes

Para actualizar un valor en un campo de arreglo, llama al método Builders.Update.Set(). Este método acepta los siguientes parámetros:

Parameter	Descripción
`field`	Una expresión que especifica el campo del arreglo a actualizar. Tipo de dato: `Expression<Func<TDocument, IEnumerable<TItem>>>`
`value`	El nuevo valor que se va a establecer en el campo del arreglo. Tipo de dato: `TItem`

Puedes usar el operador posicional con el método Set() para query y actualizar valores específicos en el arreglo. Si estás utilizando el proveedor LINQ3, el controlador .NET/C# también admite la sintaxis LINQ en lugar del operador posicional.

Las siguientes secciones describen diferentes formas de actualizar valores coincidentes en un campo de tipo arreglo.

Primer valor coincidente

Para actualizar el primer valor en un arreglo, puedes usar el operador posicional ($) o la sintaxis LINQ. Seleccione un Positional Operator o pestaña LINQ para ver la sintaxis correspondiente.

El siguiente ejemplo utiliza el método Set() y el operador posicional para actualizar el arreglo Grades en todos los documentos coincidentes. Primero, encuentra solo el primer GradeEntry objeto en el arreglo Grades donde la propiedad Grade tiene el valor "A". Luego, actualiza la propiedad Score del primer objeto GradeEntry coincidente a 100.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli") &
            Builders<Restaurant>.Filter.Eq("grades.grade", "A");
// Set Score = 100 in first GradeEntry where Grade = "A"
var update = Builders<Restaurant>.Update
    .Set("grades.$.score", 100);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

Nota

Para utilizar el operador posicional, el campo de arreglo debe formar parte del filtro de query.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli") &
            Builders<Restaurant>.Filter.Eq("grades.grade", "A");
// Set Score = 100 in first GradeEntry where Grade = "A"
var update = Builders<Restaurant>.Update
    .Set("grades.$.score", 100);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Nota

Para utilizar el operador posicional, el campo de arreglo debe formar parte del filtro de query.

El siguiente ejemplo utiliza los métodos Set() y FirstMatchingElement() para actualizar el arreglo Grades en todos los documentos coincidentes. Primero, encuentra sólo el primer objeto GradeEntry en el arreglo Grades donde la propiedad Grade tiene el valor "A". A continuación, actualiza la propiedad Score del primer objeto GradeEntry coincidente a 100.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli") &
            Builders<Restaurant>.Filter.Eq("grades.grade", "A");
// Set Score = 100 in first GradeEntry where Grade = "A"
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.FirstMatchingElement().Score, 100);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli") &
            Builders<Restaurant>.Filter.Eq("grades.grade", "A");
// Set Score = 100 in first GradeEntry where Grade = "A"
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.FirstMatchingElement().Score, 100);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Todos los valores coincidentes

Para actualizar todos los valores de un arreglo que cumplan una condición específica, puedes utilizar tanto el operador posicional filtrado ($[<identifier>]) como la sintaxis LINQ. Selecciona una pestaña Positional Operator o LINQ para ver la sintaxis correspondiente.

El siguiente ejemplo utiliza el método Set() y el operador posicional filtrado para actualizar la propiedad Score de todos los objetos GradeEntry coincidentes en el arreglo Grades a 100 en todos los documentos que coincidan.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var arrayFilters = new List<ArrayFilterDefinition>
{
    new BsonDocumentArrayFilterDefinition<Restaurant>(
        new BsonDocument
        {
            { "gradeEntry.score", new BsonDocument { { "$gte", 94} } }
        })
};
// Set Grade = "A" in all GradeEntry objects where Score >= 94
var update = Builders<Restaurant>.Update
    .Set("grades.$[gradeEntry].grade", "A");
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var result = _restaurantsCollection.UpdateMany(filter, update, updateOptions);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var arrayFilters = new List<ArrayFilterDefinition>
{
    new BsonDocumentArrayFilterDefinition<Restaurant>(
        new BsonDocument
        {
            { "gradeEntry.score", new BsonDocument { { "$gte", 94} } }
        })
};
// Set Grade = "A" in all GradeEntry objects where Score >= 94
var update = Builders<Restaurant>.Update
    .Set("grades.$[gradeEntry].grade", "A");
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var result = await _restaurantsCollection.UpdateManyAsync(filter, update, updateOptions);
return result;

El siguiente ejemplo utiliza los métodos Set() y AllMatchingElements() para actualizar la propiedad Score de todos los objetos GradeEntry coincidentes en el arreglo Grades a 100 en todos los documentos coincidentes.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var arrayFilters = new List<ArrayFilterDefinition>
{
    new BsonDocumentArrayFilterDefinition<Restaurant>(
        new BsonDocument
        {
            { "gradeEntry.score", new BsonDocument { { "$gte", 94} } }
        })
};
// Set Grade = "A" in all GradeEntry objects where Score >= 94
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.AllMatchingElements("gradeEntry").Grade, "A");
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var result = _restaurantsCollection.UpdateMany(filter, update, updateOptions);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
var arrayFilters = new List<ArrayFilterDefinition>
{
    new BsonDocumentArrayFilterDefinition<Restaurant>(
        new BsonDocument
        {
            { "gradeEntry.score", new BsonDocument { { "$gte", 94} } }
        })
};
// Set Grade = "A" in all GradeEntry objects where Score >= 94
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.AllMatchingElements("gradeEntry").Grade, "A");
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var result = await _restaurantsCollection.UpdateManyAsync(filter, update, updateOptions);
return result;

All Values

Para actualizar todos los valores en un arreglo que coincidan con un filtro de query, puedes usar el operador posicional total ($[]) o la sintaxis LINQ. Selecciona una pestaña Positional Operator o LINQ para ver la sintaxis correspondiente.

El siguiente ejemplo usa el método Set() y el operador all-positional para actualizar la propiedad Score de todos los objetos GradeEntry en el arreglo Grades a 100 en todos los documentos coincidentes.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Set Score = 100 in all GradeEntry objects
var update = Builders<Restaurant>.Update
    .Set("grades.$[].score", 100);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Set Score = 100 in all GradeEntry objects
var update = Builders<Restaurant>.Update
    .Set("grades.$[].score", 100);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

El siguiente ejemplo utiliza los métodos Set() y AllElements() para actualizar la propiedad Score de todos los objetos GradeEntry en el arreglo Grades a 100 en todos los documentos coincidentes.

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Set Score = 100 in all GradeEntry objects
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.AllElements().Score, 100);
var result = _restaurantsCollection.UpdateMany(filter, update);
return result;

var filter = Builders<Restaurant>.Filter.Eq("name", "Downtown Deli");
// Set Score = 100 in all GradeEntry objects
var update = Builders<Restaurant>.Update
    .Set(restaurant => restaurant.Grades.AllElements().Score, 100);
var result = await _restaurantsCollection.UpdateManyAsync(filter, update);
return result;

Documentación de la API

Para obtener más información sobre cualquiera de los métodos o tipos discutidos en esta guía, consulta la siguiente documentación de la API:

Volver

Campos

Reemplazar Documentos