C# 第一个（）； var docs=client.CreateDocumentQuery（coll.DocumentsLink）； foreach（单据中的var单据） { 等待client.DeleteDocumentAsync（doc.SelfLink）； } } 捕获（例外情况除外） { Trace.WriteLine（ex）； 投掷； } } } 静态void Main（字符串[]参数） { 尝试 { 程序p=新程序（）； p、 DeleteDocsAsync（）.Wait（）； } 捕获（例外） { 投掷； } } } }

以下是一种在启用了

AllowBulkExecution

的情况下删除文档的方法。这种方法以100个块的形式删除文档，因为目前cosmos DB一次最多只支持100个操作。它采用分区键属性名并使用反射来获取其值

public async Task BulkDeleteDocumentsAsync(IEnumerable<T> entities, string partitionKeyPropertyName)
    {
        List<Task> tasks = new List<Task>(100);
        foreach (var entity in entities)
        {
            var partitionKey = entity.GetType().GetProperty(partitionKeyPropertyName)?.GetValue(entity, null)?.ToString();
            if (partitionKey != null)
            {
                tasks.Add(DeleteDocumentAsync(entity.Id!, partitionKey)
                    .ContinueWith(itemResponse =>
                    {
                        if (!itemResponse.IsCompletedSuccessfully)
                        {
                            AggregateException innerExceptions = itemResponse.Exception!.Flatten();

                            if (innerExceptions.InnerExceptions.FirstOrDefault(innerEx => innerEx is CosmosException) is CosmosException cosmosException)
                            {
                                _logger.LogError($"Cosmos Exception deleting {entity.Id} {cosmosException.StatusCode} ({cosmosException.Message}).");
                            }
                            else
                            {
                                _logger.LogError($"Exception deleting {entity.Id} {innerExceptions.InnerExceptions.FirstOrDefault()}.");
                            }
                        }
                    }));
                if (tasks.Count == 100)
                {
                    await Task.WhenAll(tasks);
                    tasks.Clear();
                }
            }
        }
        await Task.WhenAll(tasks);
    }

public异步任务bulkDeleteDocumentsSync（IEnumerable实体，字符串partitionKeyPropertyName）
{
列表任务=新列表（100）；
foreach（实体中的var实体）
{
var partitionKey=entity.GetType（）.GetProperty（partitionKeyPropertyName）？.GetValue（entity，null）？.ToString（）；
if（partitionKey！=null）
{
tasks.Add（DeleteDocumentAsync（entity.Id！，partitionKey）
.ContinueWith（itemResponse=>
{
如果（！itemResponse.IsCompletedSuccessfully）
{
AggregateException innerExceptions=itemResponse.Exception！.flant（）；
if（innerExceptions.innerExceptions.FirstOrDefault（innerEx=>innerEx是宇宙感受）是宇宙感受宇宙感受
{
_logger.LogError（$“Cosmos异常删除{entity.Id}{cosmosException.StatusCode}（{cosmosException.Message}”）；
}
其他的
{
_logger.LogError（$“异常删除{entity.Id}{innerExceptions.innerExceptions.FirstOrDefault（）}”）；
}
}
}));
如果（tasks.Count==100）
{
等待任务。何时（任务）；
任务。清除（）；
}
}
}
等待任务。何时（任务）；
}

是的，我也这么想。如果删除集合，则需要再次创建存储过程和触发器。但无论如何，感谢让我知道没有其他简单的过程可以一次删除所有记录：）投票否决：没有答案：“感谢让我知道没有其他简单的过程可以一次删除所有记录”仅供参考-投票应基于您是否获得了问题的准确答案。。。不是您正在使用的软件是否支持某项功能。@TobiasJ。我同意你的想法，也许你可以使用

TimeToLive

功能，我想这将是一个更便宜的操作。这是对您要删除的每个文档的更新，DocumentDB将在后台对其进行清理，我相信DocuementDB不会对删除收费，但显然会对您的更新收费。仅当您的集合是单个分区时，使用store proc才起作用，如果我不知道如何做（在java中）我也想删除给定集合的所有文档。似乎不可能使用SQL语法。例如，“从何处删除”现在不可用。我投票支持处于审查状态的

。我不想删除重新创建父集合：对我来说，这不是一个可接受的解决方法。我真的很高兴得到一个解决方案来解决这个问题…如果您导出Azure Cosmos DB实例的模板，可以看到这个问题的链接！这是一种获取所有记录并逐个删除的方法，感谢您的回答。此方法需要更改，对DeleteDocumentSync的调用需要分区键作为RequestOptions对象的一部分。除此之外，这真的很有帮助。谢谢。将所有任务保存到列表中，然后等待它们可能会节省一些时间。我不相信这样做可以删除分区集合的所有文档，因为存储过程不能跨分区运行。

using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Util
{
    class Program
    {
        private Uri _docDbUri = new Uri("https://<nameofyourdocdb>.documents.azure.com:443/");
        private string _docDbKey = "<your primary key>";

        private async Task DeleteDocsAsync()
        {
            using (var client = new DocumentClient(_docDbUri, _docDbKey))
            {
                try
                {
                    var db = client.CreateDatabaseQuery().ToList().First();
                    var coll = client.CreateDocumentCollectionQuery(db.CollectionsLink).ToList().First();
                    var docs = client.CreateDocumentQuery(coll.DocumentsLink);
                    foreach (var doc in docs)
                    {
                        await client.DeleteDocumentAsync(doc.SelfLink);
                    }
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex);
                    throw;
                }
            }
        }



        static void Main(string[] args)
        {
            try
            {
                Program p = new Program();
                p.DeleteDocsAsync().Wait();
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}

public async Task BulkDeleteDocumentsAsync(IEnumerable<T> entities, string partitionKeyPropertyName)
    {
        List<Task> tasks = new List<Task>(100);
        foreach (var entity in entities)
        {
            var partitionKey = entity.GetType().GetProperty(partitionKeyPropertyName)?.GetValue(entity, null)?.ToString();
            if (partitionKey != null)
            {
                tasks.Add(DeleteDocumentAsync(entity.Id!, partitionKey)
                    .ContinueWith(itemResponse =>
                    {
                        if (!itemResponse.IsCompletedSuccessfully)
                        {
                            AggregateException innerExceptions = itemResponse.Exception!.Flatten();

                            if (innerExceptions.InnerExceptions.FirstOrDefault(innerEx => innerEx is CosmosException) is CosmosException cosmosException)
                            {
                                _logger.LogError($"Cosmos Exception deleting {entity.Id} {cosmosException.StatusCode} ({cosmosException.Message}).");
                            }
                            else
                            {
                                _logger.LogError($"Exception deleting {entity.Id} {innerExceptions.InnerExceptions.FirstOrDefault()}.");
                            }
                        }
                    }));
                if (tasks.Count == 100)
                {
                    await Task.WhenAll(tasks);
                    tasks.Clear();
                }
            }
        }
        await Task.WhenAll(tasks);
    }