批量写入操作

样本数据

本指南中的示例使用Atlas示例数据集中的 和sample_restaurants.restaurants sample_mflix.movies集合。要学习；了解如何创建免费的MongoDB Atlas 群集并加载示例数据集，请参阅MongoDB入门指南。

插入操作

要执行插入操作，请创建一个InsertOneModel<TDocument>实例并指定要插入的文档。

以下示例创建了 InsertOneModel<BsonDocument> 类的实例。此实例指示驱动程序将 "name"字段为 "Mongo's Deli" 的文档插入到 restaurants集合中。

var insertOneModel = new InsertOneModel<BsonDocument>(
    new BsonDocument{
        { "name", "Mongo's Deli" },
        { "cuisine", "Sandwiches" },
        { "borough", "Manhattan" },
        { "restaurant_id", "1234" }
    }
);

要插入多个文档，请为每个文档创建一个InsertOneModel<TDocument>实例。

更新操作

要更新单个文档，请创建 UpdateOneModel<TDocument> 的实例并传递以下参数：

• 查询过滤，指定用于匹配集合中文档的条件。要学习；了解有关指定查询的更多信息，请参阅MongoDB Server手册中的查询和投影操作符。

• 描述要执行的更新的更新文档。要学习；了解有关指定更新的更多信息，请参阅MongoDB Server手册中的 Update Operators。

UpdateOneModel<TDocument>实例指定与查询过滤匹配的第一个文档的更新。

在以下代码示例中，UpdateOneModel<BsonDocument>对象表示 restaurants集合上的更新操作。该操作匹配集合中 name字段的值为 "Mongo's Deli" 的第一个文档。然后，它将匹配文档中 cuisine字段的值更新为 "Sandwiches and Salads"。

var updateOneModel = new UpdateOneModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
    Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
);

要更新多个文档，请创建UpdateManyModel<TDocument>的实例并传递与UpdateOneModel<TDocument>相同的参数。 UpdateManyModel<TDocument>类指定与查询过滤匹配的所有文档的更新。

在以下代码示例中，UpdateManyModel<BsonDocument>对象表示 restaurants集合上的更新操作。该操作匹配集合中 name字段的值为 "Mongo's Deli" 的所有文档。然后，它将 cuisine字段的值更新为 "Sandwiches and Salads"。

var updateManyModel = new UpdateManyModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
    Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
);

替换操作

替换操作会删除指定文档的所有字段和值，并将其替换为您指定的新字段和值。 要执行替换操作，请创建ReplaceOneModel<TDocument>实例并传递查询过滤以及要用于替换匹配文档的字段和值。

在以下示例中，ReplaceOneModel<BsonDocument>对象表示 restaurants集合上的替换操作。该操作匹配集合中 restaurant_id字段值为 "1234" 的文档。然后，它会从此文档中删除 _id 以外的所有字段，并在 name、cuisine、borough 和 restaurant_id 字段中设置新值。

var replaceOneModel = new ReplaceOneModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "1234"),
    new BsonDocument{
        { "name", "Mongo's Pizza" },
        { "cuisine", "Pizza" },
        { "borough", "Brooklyn" },
        { "restaurant_id", "5678" }
    }
);

要替换多个文档，必须为每个文档创建一个ReplaceOneModel<TDocument>实例。

删除操作

要删除文档，请创建DeleteOneModel<TDocument>的实例并传递查询过滤，指定要删除的文档。 DeleteOneModel<TDocument>实例提供了仅删除与查询过滤匹配的第一个文档的说明。

在以下代码示例中，DeleteOneModel<BsonDocument>对象表示 restaurants集合上的删除操作。该操作匹配并删除 restaurant_id字段的值为 "5678" 的第一个文档。

var deleteOneModel = new DeleteOneModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
);

要删除多个文档，请创建 DeleteManyModel<TDocument> 的实例并传递查询过滤，指定要删除的文档。DeleteManyModel<TDocument> 的实例提供了删除与查询过滤匹配的所有文档的说明。

在以下代码示例中，DeleteManyModel<BsonDocument>对象表示 restaurants集合上的删除操作。该操作会匹配并删除 name字段的值为 "Mongo's Deli" 的所有文档。

var deleteManyModel = new DeleteManyModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli")
);

执行批量操作

为要执行的每个操作定义 WriteModel实例后，创建一个实现 IEnumerable 接口的类的实例。将您的 WriteModel 对象添加到此 IEnumerable，然后将 IEnumerable 传递给 BulkWrite() 或 BulkWriteAsync() 方法。默认下，这些方法按照列表中定义的顺序运行操作。

从以下标签页中进行选择，查看如何使用同步 BulkWrite() 方法和异步 BulkWriteAsync() 方法对 restaurants集合执行批量写入操作：

var models = new List<WriteModel<BsonDocument>>
{
    new InsertOneModel<BsonDocument>(
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Manhattan" },
            { "restaurant_id", "1234" }
        }
    ),
    new InsertOneModel<BsonDocument>(
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Brooklyn" },
            { "restaurant_id", "5678" }
        }
    ),
    new UpdateManyModel<BsonDocument>(
        Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
        Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
    ),
    new DeleteOneModel<BsonDocument>(
        Builders<BsonDocument>.Filter.Eq("restaurant_id", "1234")
    )
};
var results = collection.BulkWrite(models);
Console.WriteLine(results);

var models = new List<WriteModel<BsonDocument>>
{
    new InsertOneModel<BsonDocument>(
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Manhattan" },
            { "restaurant_id", "1234" }
        }
    ),
    new InsertOneModel<BsonDocument>(
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Brooklyn" },
            { "restaurant_id", "5678" }
        }
    ),
    new UpdateManyModel<BsonDocument>(
        Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
        Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
    ),
    new DeleteOneModel<BsonDocument>(
        Builders<BsonDocument>.Filter.Eq("restaurant_id", "1234")
    )
};
var results = await collection.BulkWriteAsync(models);
Console.WriteLine(results);

前面的代码示例生成以下输出：

MongoDB.Driver.BulkWriteResult1+Acknowledged[MongoDB.Bson.BsonDocument]

自定义批量写入操作

调用 BulkWrite() 或 BulkWriteAsync() 方法时，可以传递 BulkWriteOptions 类的实例。BulkWriteOptions 类包含以下属性，它们表示可用于配置批量写入操作的选项：

以下代码示例使用 BulkWriteOptions对象执行无序批量写入操作：

var models = new List<WriteModel<BsonDocument>>
{
new DeleteOneModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
)
};
var options = new BulkWriteOptions
{
    IsOrdered = false,
};
collection.BulkWrite(models, options);

var models = new List<WriteModel<BsonDocument>>
{
new DeleteOneModel<BsonDocument>(
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
)
};
var options = new BulkWriteOptions
{
    IsOrdered = false,
};
await collection.BulkWriteAsync(models, options);

返回值

BulkWrite() 和 BulkWriteAsync() 方法返回包含以下属性的 BulkWriteResult对象：

处理异常

如果批量写入操作中的任何操作失败， .NET/ C#驱动程序会抛出 BulkWriteError，并且不会执行任何进一步的操作。

BulkWriteError对象包含 Index属性，该属性描述导致错误的请求的索引。

插入操作

要执行插入操作，请创建 BulkWriteInsertOneModel<TDocument> 类的实例。BulkWriteInsertOneModel<TDocument> 构造函数接受以下参数：

以下示例创建 BulkWriteInsertOneModel<TDocument> 类的实例。这些实例指示驱动程序将文档插入到 sample_restaurants.restaurants 和 sample_mflix.movies 集合中。

var restaurantToInsert = new BulkWriteInsertOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    new BsonDocument{
        { "name", "Mongo's Deli" },
        { "cuisine", "Sandwiches" },
        { "borough", "Manhattan" },
        { "restaurant_id", "1234" }
    }
);
var movieToInsert = new BulkWriteInsertOneModel<BsonDocument>(
    "sample_mflix.movies",
    new BsonDocument{
        { "title", "Silly Days" },
        { "year", 2022 }
    }
);

更新操作

要更新单个文档，请创建 BulkWriteUpdateOneModel<TDocument> 类的实例。BulkWriteUpdateOneModel<TDocument> 构造函数接受以下参数：

在以下代码示例中，BulkWriteUpdateOneModel<BsonDocument> 对象表示对 sample_restaurants.restaurants 和 sample_mflix.movies 集合的更新操作。

var restaurantUpdate = new BulkWriteUpdateOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
    Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
);
var movieUpdate = new BulkWriteUpdateOneModel<BsonDocument>(
    "sample_mflix.movies",
    Builders<BsonDocument>.Filter.Eq("title", "Carrie"),
    Builders<BsonDocument>.Update.Set("seen", True)
);

要更新多个文档，请创建 BulkWriteUpdateManyModel<TDocument> 类的实例。此类的构造函数接受与 BulkWriteUpdateOneModel<TDocument> 构造函数相同的参数。BulkWriteUpdateManyModel<TDocument>操作会更新与查询过滤匹配的所有文档。

在以下代码示例中，BulkWriteUpdateManyModel<BsonDocument>对象表示 sample_restaurants.restaurants集合上的更新操作。该操作匹配集合中 name字段的值为 "Starbucks" 的所有文档。然后，它将 cuisine字段的值更新为 "Coffee (Chain)"。

var updateManyModel = new BulkWriteUpdateManyModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("name", "Starbucks"),
    Builders<BsonDocument>.Update.Set("cuisine", "Coffee (Chain)")
);

替换操作

要替换文档中的字段，请创建 BulkWriteReplaceOneModel<TDocument> 类的实例。BulkWriteReplaceOneModel<TDocument> 构造函数接受以下参数：

在以下示例中，BulkWriteReplaceOneModel<BsonDocument> 对象表示对 sample_restaurants.restaurants 和 sample_mflix.movies 集合的替换操作。

var restaurantReplacement = new BulkWriteReplaceOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "1234"),
    new BsonDocument{
        { "name", "Mongo's Pizza" },
        { "cuisine", "Pizza" },
        { "borough", "Brooklyn" },
        { "restaurant_id", "5678" }
    }
);
var movieReplacement = new BulkWriteReplaceOneModel<BsonDocument>(
    "sample_mflix.movies",
    Builders<BsonDocument>.Filter.Eq("title", "Insomnia"),
    new BsonDocument{
        { "name", "Loving Sylvie" },
        { "year", 1999 }
    }
);

删除操作

要删除文档，请创建 BulkWriteDeleteOneModel<TDocument> 类的实例。BulkWriteDeleteOneModel<TDocument> 构造函数接受以下参数：

在以下代码示例中，BulkWriteDeleteOneModel<BsonDocument> 对象表示对 sample_restaurants.restaurants 和 sample_mflix.movies 集合删除操作。

var restaurantToDelete = new BulkWriteDeleteOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
);
var movieToDelete = new BulkWriteDeleteOneModel<BsonDocument>(
    "sample_mflix.movies",
    Builders<BsonDocument>.Filter.Eq("title", "Mr. Nobody")
);

要删除多个文档，请创建 BulkWriteDeleteManyModel<TDocument> 类的实例，并传递指定要删除的文档的查询过滤。DeleteMany操作会删除与查询过滤匹配的所有文档。

在以下代码示例中，BulkWriteDeleteManyModel<BsonDocument>对象表示 sample_restaurants.restaurants集合上的删除操作。该操作会匹配并删除 name字段的值为 "Mongo's Deli" 的所有文档。

var deleteManyModel = new BulkWriteDeleteManyModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli")
);

执行批量操作

为要执行的每个操作定义 BulkWriteModel实例后，创建一个实现 IReadOnlyList 接口的类的实例。将您的 BulkWriteModel 对象添加到此 IReadOnlyList 中，然后将 IReadOnlyList 传递给 BulkWrite() 或 BulkWriteAsync() 方法。默认，这些方法按照在集合中定义的顺序运行操作。

从以下标签页中进行选择，查看如何使用同步 BulkWrite() 方法和异步 BulkWriteAsync() 方法对多个命名空间执行批量写入操作。

var client = new MongoClient("mongodb://localhost:27017");
var restaurantNamespace = "sample_restaurants.restaurants";
var movieNamespace = "sample_mflix.movies";
var bulkWriteModels = new[]
{
    new BulkWriteInsertOneModel<BsonDocument>(
        restaurantNamespace,
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Manhattan" },
            { "restaurant_id", "1234" }
        }
    ),
    new BulkWriteInsertOneModel<BsonDocument>(
        movieNamespace,
        new BsonDocument{
            { "name", "Sarah's Secret" },
            { "year", 1988 }
        }
    ),
    new BulkWriteUpdateManyModel<BsonDocument>(
        restaurantNamespace,
        Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
        Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
    ),
    new BulkWriteDeleteOneModel<BsonDocument>(
        movieNamespace,
        Builders<BsonDocument>.Filter.Eq("title", "House")
    )
};
var result = client.BulkWrite(bulkWriteModels);
Console.WriteLine(result);

var client = new MongoClient("mongodb://localhost:27017");
var restaurantNamespace = "sample_restaurants.restaurants";
var movieNamespace = "sample_mflix.movies";
var bulkWriteModels = new[]
{
    new BulkWriteInsertOneModel<BsonDocument>(
        restaurantNamespace,
        new BsonDocument{
            { "name", "Mongo's Deli" },
            { "cuisine", "Sandwiches" },
            { "borough", "Manhattan" },
            { "restaurant_id", "1234" }
        }
    ),
    new BulkWriteInsertOneModel<BsonDocument>(
        movieNamespace,
        new BsonDocument{
            { "name", "Sarah's Secret" },
            { "year", 1988 }
        }
    ),
    new BulkWriteUpdateManyModel<BsonDocument>(
        restaurantNamespace,
        Builders<BsonDocument>.Filter.Eq("name", "Mongo's Deli"),
        Builders<BsonDocument>.Update.Set("cuisine", "Sandwiches and Salads")
    ),
    new BulkWriteDeleteOneModel<BsonDocument>(
        movieNamespace,
        Builders<BsonDocument>.Filter.Eq("title", "House")
    )
};
var result = await client.BulkWriteAsync(bulkWriteModels);
Console.WriteLine(result);

前面的代码示例生成以下输出：

BulkWriteResult({'writeErrors': [], 'writeConcernErrors': [], 'nInserted': 2, 'nUpserted': 0, 'nMatched': 2, 'nModified': 2, 'nRemoved': 1, 'upserted': []}, acknowledged=True)

自定义批量写入

调用 BulkWrite() 或 BulkWriteAsync() 方法时，可以传递 ClientBulkWriteOptions 类的实例。ClientBulkWriteOptions 类包含以下属性，它们表示可用于配置批量写入操作的选项：

以下代码示例使用 ClientBulkWriteOptions对象自定义批量写入操作：

var client = new MongoClient("mongodb://localhost:27017");
var deleteOneModel = new BulkWriteDeleteOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
);
var clientBulkWriteOptions = new ClientBulkWriteOptions
{
    IsOrdered = false,
    WriteConcern = WriteConcern.Unacknowledged,
    VerboseResult = true
};
var result = client.BulkWrite(deleteOneModel, clientBulkWriteOptions);

var client = new MongoClient("mongodb://localhost:27017");
var deleteOneModel = new BulkWriteDeleteOneModel<BsonDocument>(
    "sample_restaurants.restaurants",
    Builders<BsonDocument>.Filter.Eq("restaurant_id", "5678")
);
var clientBulkWriteOptions = new ClientBulkWriteOptions
{
    IsOrdered = false,
    WriteConcern = WriteConcern.Unacknowledged,
    VerboseResult = true
};
var result = await client.BulkWriteAsync(deleteOneModel, clientBulkWriteOptions);

返回值

BulkWrite() 和 BulkWriteAsync() 方法返回包含以下属性的 ClientBulkWriteResult对象：

处理异常

如果批量写入操作中的任何操作失败， .NET/ C#驱动程序会抛出 ClientBulkWriteException，并且不会执行任何进一步的操作。

ClientBulkWriteException对象包含以下属性：

API 文档

要进一步了解本指南所讨论的任何方法或类型，请参阅以下 API 文档：

• 集合批量写入

  • BulkWrite()

  • BulkWriteAsync()

  • BulkWriteOptions

  • BulkWriteResult

  • InsertOneModel

  • UpdateOneModel

  • UpdateManyModel

  • ReplaceOneModel

  • DeleteOneModel

  • DeleteManyModel

  • BulkWriteError

• 客户端批量写入

  • BulkWrite()

  • BulkWriteAsync()

  • ClientBulkWriteOptions

  • ClientBulkWriteResult

  • BulkWriteInsertOneModel

  • BulkWriteUpdateOneModel

  • BulkWriteUpdateManyModel

  • BulkWriteReplaceOneModel

  • BulkWriteDeleteOneModel

  • BulkWriteDeleteManyModel

  • BulkWriteInsertOneResult

  • BulkWriteUpdateResult

  • BulkWriteDeleteResult

  • ClientBulkWriteException