.NET中MongoDB之CRUD

参考文档

• https://docs.mongoing.com/mongodb-crud-operations
• https://docs.mongodb.com/manual/crud/
• https://docs.microsoft.com/zh-cn/aspnet/core/tutorials/first-mongo-app?view=aspnetcore-6.0&tabs=visual-studio#add-a-crud-operations-service

注意

• 使用use命令切换之前您无需创建数据库。当您第一次在数据库中存储数据时（例如在数据库中创建第一个集合），MongoDB会创建数据库
• MongoDB 中默认的数据库为 test，如果你没有创建新的数据库，集合将存放在 test 数据库中
• MongoDB向指定集合中插入文档时，如果指定集合不存在，MongoDB则会自动创建该集合
• 在MongoDB中，存储在集合中的每个文档都需要一个唯一的_id字段作为主键。 如果插入的文档省略_id字段，则MongoDB驱动程序会自动为_id字段生成ObjectId。
• MongoDB中的所有写操作都是单个文档级别的原子操作
• .NET CORE或更高版本请根据MongoDB版本安装 MongoDB.Driver Nuget包

新增

db.collection.insertOne()

插入一个文件

返回一个文档，其中包含新插入的文档的_id字段值

关于writeConcern请参考 https://mongoing.com/archives/2916

该操作不支持 db.collection.explain() 查询计划

语法

db.collection.insertOne(
   <document>,
   {
      writeConcern: <document>
   }
)

实例代码

• MongoDB Shell

db.inventory.insertOne
(
    {
        item: "canvas",
        qty: 100,
        tags: ["cotton"],
        size: { h: 28, w: 35.5, uom: "cm" }
     }
)

• C#

var document = new BsonDocument
{
    { "item", "canvas" },
    { "qty", 100 },
    { "tags", new BsonArray { "cotton" } },
    { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } }
};
collection.InsertOne(document);

db.collection.insertMany()

插入多个文件

返回包含新插入的文档_id字段值的文档

ordered表示是否按顺序执行插入操作，默认为true

顺序添加的速度要慢于不按顺序添加的。

按照顺序添加的 操作遇到错误会直接停止，而不按照顺序的会继续执行在队列中的写操作

语法

db.collection.insertMany(
   [ <document 1> , <document 2>, ... ],
   {
      writeConcern: <document>,
      ordered: <boolean>
   }
)

实例代码

• MongoDB Shell

db.inventory.insertMany([
        { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
        { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
        { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
    ])

• C#

var documents = new BsonDocument[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "tags", new BsonArray { "blank", "red" } },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, {  "uom", "cm"} } }
    },
    new BsonDocument
    {
        { "item", "mat" },
        { "qty", 85 },
        { "tags", new BsonArray { "gray" } },
        { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, {  "uom", "cm"} } }
    },
    new BsonDocument
    {
        { "item", "mousepad" },
        { "qty", 25 },
        { "tags", new BsonArray { "gel", "blue" } },
        { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, {  "uom", "cm"} } }
    },
};
collection.InsertMany(documents);

db.collection.insert()

将单个文档或多个文档插入到集合中。该方法在MongoSH已被标记过期，不推荐使用。

语法

db.collection.insert(
   <document or array of documents>,  //数组或者文档都可以添加
   {
     writeConcern: <document>,
     ordered: <boolean> //跟insertMany()操作作用一致
   }
)

实例代码

• MongoDB Shell

db.inventory.insert
(
    {
        item: "canvas",
        qty: 100,
        tags: ["cotton"],
        size: { h: 28, w: 35.5, uom: "cm" }
     }
)

db.collection.bulkWrite()

批量执行写入操作

operation 要执行的操作，可用值有insertOne,deleteOne,updateOne,deleteMany,updateMany,replaceOne

语法

db.collection.bulkWrite(
   [ <operation 1>, <operation 2>, ... ],
   {
      writeConcern : <document>,
      ordered : <boolean>
   }
)

实例代码

• MongoDB Shell

db.collection.bulkWrite( [
   { insertOne : { "document" : <document> } }
] )

• C#

 var collection = db.GetCollection<Inventory>("test");
 var requests = new List<WriteModel<Inventory>>()
 {
  new InsertOneModel<Inventory>(new Inventory()),
  new InsertOneModel<Inventory>(new Inventory())
 };
 collection.BulkWrite(requests);

查询

查询全部

• SQL

SELECT * FROM Inventory

• MongoDB Shell

db.inventory.find( {} )

• C#

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.Find(filter).ToList();

条件查询

逻辑查询运算符

$and 使用逻辑AND连接查询子句，返回与这两个子句条件匹配的所有文档

$not 反转查询表达式的效果，并返回与查询表达式_不_匹配的文档。

$nor 用逻辑NOR连接查询子句，返回所有不能匹配这两个子句的文档。

$or 用逻辑OR连接查询子句，返回与任一子句条件匹配的所有文档

比较查询运算符

$eq 匹配等于指定值的值

$gt 匹配大于指定值的值

$gte 匹配大于或等于指定值的值

$in 匹配数组中指定的任何值

$lt 匹配小于指定值的值

$lte 匹配小于或等于指定值的值

$ne 匹配所有不等于指定值的值

$nin 不匹配数组中指定的任何值

更多其他运算符

https://docs.mongoing.com/can-kao/yun-suan-fu

• 插入文档

db.inventory.insertMany([
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

• SQL

SELECT * FROM Inventory WHERE status = "D"

SELECT * FROM inventory WHERE status in ("A", "D")

SELECT * FROM inventory WHERE status = "A" AND qty < 30

SELECT * FROM inventory WHERE status = "A" OR qty < 30

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

• MongoDB Shell

在对相同字段进行等值检索的时候更建议使用$in而不是$or

MongoDB支持正则表达式操作符$regex来做字符串模式匹配

db.inventory.find( {status:"D"} )

db.inventory.find( { status: { $in: [ "A", "D" ] } } )

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

• C#

var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" });
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(
    builder.Eq("status", "A"),
    builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p"))));
var result = collection.Find(filter).ToList();

嵌套文档查询

• 插入文档

db.inventory.insertMany([
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

• MongoDB Shell

整个嵌入式文档上的相等匹配要求与指定的文档完全匹配，包括字段顺序。

要在嵌入式/嵌套文档中的字段上指定查询条件，请使用点符号（“ field.nestedField”）

db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

db.inventory.find( { "size.uom": "in" } )

db.inventory.find( { "size.h": { $lt: 15 } } )

db.inventory.find( { "size.h": { $lt: 15 }, "size.uom": "in", status: "D" } )

• C#

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("size.uom", "in");
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Lt("size.h", 15);
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Lt("size.h", 15), builder.Eq("size.uom", "in"), builder.Eq("status", "D"));
var result = collection.Find(filter).ToList();

数组查询

• 插入文档

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
   { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
   { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
   { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
   { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);

• MongoDB Shell

使用点运算符查询时，dim_cm.1 必须在双引号内

//顺序都必须一致才能查询出来
db.inventory.find( { tags: ["red", "blank"] } )
//查询tags中包含red和blank元素的文档，不考虑顺序
db.inventory.find( { tags: { $all: ["red", "blank"] } } )、
//查询所有文档中包含tags字段，如果tags为数组则查询数组中包含red元素的文档
db.inventory.find( { tags: "red" } )
//查询所有文档中包含dim_cm字段，如dim_cm为数组则查询数组里面存在大于25的元素的文档
db.inventory.find( { dim_cm: { $gt: 25 } } )
//查询dim_cm数组元素中存在大于15同时又存在小于20的文档
db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )
//查询dim_cm数组元素中至少存在一个大于22且小于30的文档
db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )
//查询dim_cm数组第二个元素大于25的相关文档
db.inventory.find( { "dim_cm.1": { $gt: 25 } } )
//查询tags数组长度为3的相关文档
db.inventory.find( { "tags": { $size: 3 } } )

• C#

var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("tags", "red");
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25);
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20));
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Size("tags", 3);
var result = collection.Find(filter).ToList();

嵌套文档数组查询

• 插入文档

db.inventory.insertMany( [
   { item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
   { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
   { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
   { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

• MongoDB Shell

//查询instock数组包含指定元素的相关文档，顺序都必须一致才会匹配
db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )
//查询instock数组中存在qty字段小于等于20的元素的相关文档
db.inventory.find( { 'instock.qty': { $lte: 20 } } )
//查询instock数组中第一个元素qty字段小于等于20的相关文档
db.inventory.find( { 'instock.0.qty': { $lte: 20 } } )
//查询instock数组元素中包含qty=5且warehouse=A的相关文档
db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )
//查询instock数组中至少存在一个qty字段大于10且小于等20的元素的相关文档（只能是同一个数组元素的qty字段）
db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )
//查询instock数组中存在qty字段大于10且小于20的元素相关的文档（可以是不同元素也可以是同一元素的qty字段）
db.inventory.find( { "instock.qty": { $gt: 10,  $lte: 20 } } )
//查询instock数组中存在qty字段等于10且warehouse等于A的元素相关的文档（可以是不同元素也可以是同一元素的qty字段）
db.inventory.find( { "instock.qty": 5, "instock.warehouse": "A" } )

• C#

var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "warehouse", "A" }, { "qty", 5 } });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Lte("instock.qty", 20);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Lte("instock.0.qty", 20);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", new BsonDocument { { "$gt", 10 }, { "$lte", 20 } } } });
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("instock.qty", 10), builder.Lte("instock.qty", 20));
var result = collection.Find(filter).ToList();

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("instock.qty", 5), builder.Eq("instock.warehouse", "A"));
var result = collection.Find(filter).ToList();

查询指定字段

• 插入文档

db.inventory.insertMany( [
  { item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] },
  { item: "notebook", status: "A",  size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] },
  { item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] },
  { item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] },
  { item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" }, instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

• SQL

SELECT _id, item, status from inventory WHERE status = "A"
SELECT item, status from inventory WHERE status = "A"
SELECT _id, size, item from inventory WHERE status = "A"

• MongoDB Shell

//根据指定条件查询item,status字段(_id字段会默认返回)
db.inventory.find( { status: "A" }, { item: 1, status: 1 } )
//根据指定条件查询item,status字段
db.inventory.find( { status: "A" }, { item: 1, status: 1, _id: 0 } )
//除开status，instock其他都字段都返回
db.inventory.find( { status: "A" }, { status: 0, instock: 0 } )
//返回_id，item，status和size中的uom字段
db.inventory.find(
   { status: "A" },
   { item: 1, status: 1, "size.uom": 1 }
)
//除开size中的uom字段，其他都返回
db.inventory.find(
   { status: "A" },
   { "size.uom": 0 }
)
//返回item，status，和instock数组中的qty字段
db.inventory.find( { status: "A" }, { item: 1, status: 1, "instock.qty": 1 } )
//返回item，status，和instock数组中的最后一个元素
db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

• C#

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Exclude("_id");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("status").Exclude("instock");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("instock.qty");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

NULL和缺失字段查询

• 插入文档

db.inventory.insertMany([
   { _id: 1, item: null },
   { _id: 2 }
])

• MongoDB Shell

关于$type 请参考 https://docs.mongodb.com/v4.0/reference/bson-types/

关于$exists 请参考 https://docs.mongodb.com/v4.0/reference/operator/query/exists/#op._S_exists

//会查询出item为NULL和不存在item字段的文档
db.inventory.find( { item: null } )
//只会查询出包含item字段且值为NULL的文档
db.inventory.find( { item : { $type: 10 } } )
//只会查询出不包含item字段的文档
db.inventory.find( { item : { $exists: false } } )

• C#

请使用BsonNull.Value去查询MongoDB中的NULL值和不存在的字段

var filter = Builders<BsonDocument>.Filter.Eq("item", BsonNull.Value);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Type("item", BsonType.Null);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Exists("item", false);
var result = collection.Find(filter).ToList();

修改

插入文档

db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] );

db.inventory.updateOne()

更新单个文档

查找与过滤器匹配的第一个文档，并应用指定的更新进行修改。

语法

db.collection.updateOne(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>        // Available starting in MongoDB 4.2.1
   }
)

• filter 更新的选择标准。可以使用与find()方法相同的query selectors。 指定一个空文档{ }以更新集合中的所有文档。
• update 要应用的修改。可以是以下之一： 1. 更新文件：仅包含更新运算符表达式。有关更多信息，请参见 使用更新运算符表达式文档进行更新。 2. 聚合管道（从MongoDB 4.2开始）：仅包含以下聚合阶段： a. $addFields及其别名 $set b. $project及其别名 $unset c. replaceRoot及其别名$replaceWith。
• upsert 可选的。当true，updateOne()时： 1. 如果没有文档匹配filter，则创建一个新文档。 2. 更新匹配filter的文档。 要避免多次 upsert，请确保filter字段为唯一索引。 默认为false。
• writeConcern 可选的。表示写关注的文件。省略使用默认写入问题。 如果在事务中运行，请不要为操作明确设置写关注点。
• collation 可选的。 指定要用于操作的排序规则。 排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大写和重音符号的规则
• arrayFilters 可选的。过滤器文档的 array，用于确定要在 array 字段上为更新操作修改哪些 array 元素
• hint 可选的。一个文档或字符串，它指定用于支持查询谓词的索引。 该选项可以采用索引规范文档或索引名称字符串。 如指定的索引不存在，则操作错误。

实例代码

• MongoDB Shell

db.inventory.updateOne(
    { item: "paper" },
    {
        $set: { "size.uom": "cm", status: "P" },
        $currentDate: { lastModified: true }
    }
)

使用$set 运算符将size.uom字段的值更新为“ cm”，将状态字段的值更新为“ P”

使用$currentDate运算符将lastModified字段的值更新为当前日期。 如果lastModified字段不存在，则$currentDate将创建该字段。

• C#

var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var update = Builders<BsonDocument>.Update.Set("size.uom", "cm").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateOne(filter, update);

db.inventory.updateMany()

更新多个文档

语法

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>        // Available starting in MongoDB 4.2.1
   }
)

• 参数解释同db.inventory.updateOne()

实例代码

• MongoDB Shell

db.inventory.updateMany(
   { "qty": { $lt: 50 } },
   {
     $set: { "size.uom": "in", status: "P" },
     $currentDate: { lastModified: true }
   }
)

• C#

var filter = Builders<BsonDocument>.Filter.Lt("qty", 50);
var update = Builders<BsonDocument>.Update.Set("size.uom", "in").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateMany(filter, update);

db.inventory.replaceOne()

替换文档

要替换_id字段以外的文档的全部内容，请将一个全新的文档作为第二个参数传递给

当替换一个文档时，替换文档必须只包含字段/值对;即不包括更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中，由于_id字段是不可变的，因此可以省略_id字段。但是，如果您确实包含_id字段，则它必须与当前值具有相同的值。

语法

db.collection.replaceOne(
   <filter>,
   <replacement>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>
   }
)

• 参数解释同db.inventory.updateOne()

实例代码

• MongoDB Shell

db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

• C#

var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var replacement = new BsonDocument
{
    { "item", "paper" },
    { "instock", new BsonArray
        {
            new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
            new BsonDocument { { "warehouse", "B" }, { "qty", 40 } } }
        }
};
var result = collection.ReplaceOne(filter, replacement);

db.collection.update()

更新

该语法在.NET nuget包 MongoDB.Driver中并不存在对应方法

语法

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

• multi 可选的。如果设置为true，则更新符合query条件的多个文档。如果设置为false，则更新一个文档。默认的 value 是false。
• 其他同db.inventory.updateOne()

实例代码

• MongoDB Shell

db.books.update(
   { stock: { $lte: 10 } },
   { $set: { reorder: true } },
   { multi: true }
)

其他方法

• db.collection.findOneAndReplace()
• db.collection.findOneAndUpdate()
• db.collection.findAndModify()
• db.collection.save()
• db.collection.bulkWrite()

删除

插入文档

db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
] );

db.collection.deleteMany()

要删除集合中的所有文档，请将空的filter文档{}传递给db.collection.deleteMany() 方法

您可以指定标准或过滤器，以标识要删除的文档。 filter使用与读取操作相同的语法。

语法

db.collection.deleteMany(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

• 参数解释同db.inventory.updateOne()

实例代码

• MongoDB Shell

db.inventory.deleteMany({})  

db.inventory.deleteMany({ status : "A" })

• C#

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.DeleteMany(filter);

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

db.collection.deleteOne()

仅删除一个符合条件的文档(即使多个文档可以与指定过滤器匹配)

实例代码

• MongoDB Shell

db.inventory.deleteOne( { status: "D" } )

• C#

var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
var result = collection.DeleteOne(filter);