教程:生成一个用于在 Azure Cosmos DB SQL API 帐户中管理数据的 .NET 控制台应用

适用于: SQL API

欢迎使用 Azure Cosmos DB SQL API 入门教程。 学习本教程后,将拥有一个可创建并查询 Azure Cosmos DB 资源的控制台应用程序。

本教程使用 3.0 版或更高版的 Azure Cosmos DB .NET SDK。 可以使用 .NET Framework 或 .NET Core

本教程涉及:

  • 创建并连接到 Azure Cosmos 帐户
  • 在 Visual Studio 中配置项目
  • 创建数据库和容器
  • 向容器添加项
  • 查询容器
  • 对项执行创建、读取、更新和删除 (CRUD) 操作
  • 删除数据库

没有时间? 不必担心! 可在 GitHub上获取完整的解决方案。 有关快速说明,请转到“获取完整的教程解决方案”部分

现在,让我们开始吧!

先决条件

步骤 1:创建 Azure Cosmos DB 帐户

让我们创建一个 Azure Cosmos DB 帐户。 如果已经有要使用的帐户,请跳过此部分。 若要使用 Azure Cosmos DB 模拟器,请按照 Azure Cosmos DB 模拟器中的步骤设置该模拟器。 然后跳转到步骤 2:设置 Visual Studio 项目

  1. 在 Azure 门户菜单或主页中,选择“创建资源” 。

  2. 在“新建”页面中搜索“Azure Cosmos DB”,然后选择它。

  3. 在“Azure Cosmos DB”页上,选择“创建”。

  4. 在“创建 Azure Cosmos DB 帐户”页中,输入新 Azure Cosmos 帐户的基本设置。

    设置 说明
    订阅 订阅名称 选择要用于此 Azure Cosmos 帐户的 Azure 订阅。
    资源组 资源组名称 选择一个资源组,或者选择“新建”,然后输入新资源组的唯一名称。
    帐户名 唯一的名称 输入标识此 Azure Cosmos 帐户的名称。 由于 documents.azure.cn 将追加到所提供的名称以创建 URI,因此,请使用唯一的名称。

    名称只能包含小写字母、数字和连字符 (-)。 它的长度必须介于 3-44 个字符之间。
    API 要创建的帐户的类型 选择“Core (SQL)”,以便使用 SQL 语法创建文档数据库并进行查询。

    API 确定要创建的帐户的类型。 Azure Cosmos DB 提供五种 API:适用于文档数据的 Core (SQL) 和 MongoDB、适用于图形数据的 Gremlin、Azure 表和 Cassandra。 目前,你必须为每种 API 创建单独的帐户。

    详细了解 SQL API
    位置 离用户最近的区域 选择用于托管 Azure Cosmos DB 帐户的地理位置。 使用离用户最近的位置,使他们能够以最快的速度访问数据。
    容量模式 预配吞吐量或无服务器 选择“预配吞吐量”以在预配吞吐量模式下创建帐户。 选择“无服务器”以在无服务器模式下创建帐户。
    应用免费层折扣 “应用”或“不应用” 使用 Azure Cosmos DB 免费层,你将在帐户中获得每秒前 1000 RU 的免费吞吐量和 25 GB 的免费存储。 了解免费层的详细信息。

    注意

    每个 Azure 订阅最多可以有一个免费层 Azure Cosmos DB 帐户,并且你必须在创建帐户时选择加入使用。 如果看不到用于应用免费层折扣的选项,这意味着订阅中的另一个帐户已启用免费层。

    The new account page for Azure Cosmos DB

  5. 在“全局分发”选项卡中,配置以下详细信息。 对于本快速入门,可以保留默认值:

    设置 说明
    异地冗余 禁用 通过将你的区域与某个配对区域进行配对来启用或禁用帐户的多区域分发。 稍后可以将更多区域添加到帐户。
    多区域写入 禁用 借助多区域写入功能,可以利用全中国的数据库和容器的预配吞吐量。

    注意

    如果选择“无服务器”作为“容量模式”,则以下选项不可用 :

    • 应用免费层折扣
    • 异地冗余
    • 多区域写入
  6. (可选)可以在以下选项卡中配置其他详细信息:

    • 网络 - 配置来自虚拟网络的访问

    • 备份策略 - 配置定期备份策略。

    • 加密 - 使用服务管理的密钥或客户管理的密钥

    • 标记 - 标记是名称/值对,通过将相同的标记应用到多个资源和资源组,可以对资源进行分类并查看合并的账单。

  7. 选择“查看 + 创建”。

  8. 检查帐户设置,然后选择“创建”。 创建帐户需要几分钟时间。 等待门户页显示“你的部署已完成”消息。

    The Azure portal Notifications pane

  9. 选择“转到资源”,转到 Azure Cosmos DB 帐户页。

    The Azure Cosmos DB account page

步骤 2:设置 Visual Studio 项目

  1. 打开 Visual Studio 并选择“创建新项目”。

  2. 在“创建新项目”中,选择用于 C# 的“控制台应用(.NET Framework)”,然后选择“下一步”。

  3. 将项目命名为 CosmosGettingStartedTutorial,然后选择“创建”。

    Configure your project

  4. 在“解决方案资源管理器”中,右键单击 Visual Studio 解决方案下方的新控制台应用程序,然后选择“管理 NuGet 包”。

  5. 在“NuGet 包管理器”中选择“浏览”,然后搜索“Microsoft.Azure.Cosmos”。 选择“Microsoft.Azure.Cosmos”,然后选择“安装”。

    Install NuGet for Azure Cosmos DB Client SDK

    Azure Cosmos DB SQL API 客户端库的包 ID 是 Azure Cosmos DB 客户端库

很好! 现在,我们已完成安装,让我们开始编写一些代码。 如需本教程的已完成的项目,请参阅 Developing a .NET console app using Azure Cosmos DB(使用 Azure Cosmos DB 开发 .NET 控制台应用)。

步骤 3:连接到 Azure Cosmos DB 帐户

  1. Program.cs 文件中 C# 应用程序开头的引用替换为以下引用:

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
  2. 将这些常量和变量添加到 Program 类中。

    public class Program
    {
        // ADD THIS PART TO YOUR CODE
    
        // The Azure Cosmos DB endpoint for running this sample.
        private static readonly string EndpointUri = "<your endpoint here>";
        // The primary key for the Azure Cosmos account.
        private static readonly string PrimaryKey = "<your primary key>";
    
        // The Cosmos client instance
        private CosmosClient cosmosClient;
    
        // The database we will create
        private Database database;
    
        // The container we will create.
        private Container container;
    
        // The name of the database and container we will create
        private string databaseId = "FamilyDatabase";
        private string containerId = "FamilyContainer";
    }
    

    注意

    如果你熟悉旧版 .NET SDK,则可能熟悉术语“集合”和“文档”。 由于 Azure Cosmos DB 支持多个 API 模型,因此 3.0 版的 .NET SDK 使用通用术语“容器”和“项”。 容器可以是集合、图或表。 项可以是文档、边缘/顶点或行,是容器中的内容。 有关详细信息,请参阅在 Azure Cosmos DB 中使用数据库、容器和项

  3. 打开 Azure 门户。 找到 Azure Cosmos DB 帐户,然后选择“密钥”。

    Get Azure Cosmos DB keys from Azure portal

  4. Program.cs 中,将 <your endpoint URL> 替换为 URI 的值。 将 <your primary key> 替换为“主密钥”的值。

  5. Main 方法下面,添加名为 GetStartedDemoAsync 的新异步任务,将新的 CosmosClient 实例化。

    public static async Task Main(string[] args)
    {
    }
    
    // ADD THIS PART TO YOUR CODE
    /*
        Entry point to call methods that operate on Azure Cosmos DB resources in this sample
    */
    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
    }
    

    我们使用 GetStartedDemoAsync 作为入口点,该入口点调用在 Azure Cosmos DB 资源上运行的方法。

  6. 添加以下代码,从 Main 方法中运行 GetStartedDemoAsync 异步任务。 Main 方法将捕获异常并将它们写到控制台上。

    public static async Task Main(string[] args)
    {
        try
        {
            Console.WriteLine("Beginning operations...\n");
            Program p = new Program();
            await p.GetStartedDemoAsync();
    
        }
        catch (CosmosException de)
        {
            Exception baseException = de.GetBaseException();
            Console.WriteLine("{0} error occurred: {1}", de.StatusCode, de);
        }
        catch (Exception e)
        {
            Console.WriteLine("Error: {0}", e);
        }
        finally
        {
            Console.WriteLine("End of demo, press any key to exit.");
            Console.ReadKey();
        }
    }
    
    
  7. 选择 F5 来运行应用程序。

    主机显示消息:“演示结束,按任意键退出。”此消息确认应用程序已连接到 Azure Cosmos DB。 然后即可关闭控制台窗口。

祝贺你! 你已成功连接到 Azure Cosmos DB 帐户。

步骤 4:创建数据库

数据库是跨容器分区的项的逻辑容器。 CosmosClient 类的 CreateDatabaseIfNotExistsAsyncCreateDatabaseAsync 方法可以创建数据库。

  1. 复制 CreateDatabaseAsync 方法并将其粘贴到 GetStartedDemoAsync 方法下面。

    /// <summary>
    /// Create the database if it does not exist
    /// </summary>
    private async Task CreateDatabaseAsync()
    {
        // Create a new database
        this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
        Console.WriteLine("Created Database: {0}\n", this.database.Id);
    }
    
    

    CreateDatabaseAsync 使用 databaseId 字段中指定的 ID FamilyDatabase 来创建新数据库(如果尚不存在该数据库)。

  2. 复制并粘贴以下代码,在其中实例化 CosmosClient 来调用刚添加的 CreateDatabaseAsync 方法。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
    
        //ADD THIS PART TO YOUR CODE
        await this.CreateDatabaseAsync();
    }
    

    Program.cs 现在应如下所示,其中填充了终结点和主密钥。

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
    namespace CosmosGettingStartedTutorial
    {
        class Program
        {
            // The Azure Cosmos DB endpoint for running this sample.
            private static readonly string EndpointUri = "<your endpoint here>";
            // The primary key for the Azure Cosmos account.
            private static readonly string PrimaryKey = "<your primary key>";
    
            // The Cosmos client instance
            private CosmosClient cosmosClient;
    
            // The database we will create
            private Database database;
    
            // The container we will create.
            private Container container;
    
            // The name of the database and container we will create
            private string databaseId = "FamilyDatabase";
            private string containerId = "FamilyContainer";
    
            public static async Task Main(string[] args)
            {
                try
                {
                    Console.WriteLine("Beginning operations...");
                    Program p = new Program();
                    await p.GetStartedDemoAsync();
                }
                catch (CosmosException de)
                {
                    Exception baseException = de.GetBaseException();
                    Console.WriteLine("{0} error occurred: {1}\n", de.StatusCode, de);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: {0}\n", e);
                }
                finally
                {
                    Console.WriteLine("End of demo, press any key to exit.");
                    Console.ReadKey();
                }
            }
    
            /// <summary>
            /// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
            /// </summary>
            public async Task GetStartedDemoAsync()
            {
                // Create a new instance of the Cosmos Client
                this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
                await this.CreateDatabaseAsync();
            }
    
            /// <summary>
            /// Create the database if it does not exist
            /// </summary>
            private async Task CreateDatabaseAsync()
            {
                // Create a new database
                this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
                Console.WriteLine("Created Database: {0}\n", this.database.Id);
            }
        }
    }
    
  3. 选择 F5 来运行应用程序。

    注意

    如果收到“503 服务不可用异常”错误,则直接连接模式所需的端口可能已被防火墙阻止。 若要解决此问题,打开所需端口或使用网关模式连接,如以下代码所示:

     // Create a new instance of the Cosmos Client in Gateway mode
     this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey, new CosmosClientOptions()
            {
                ConnectionMode = ConnectionMode.Gateway
            });
    

祝贺你! 你已成功创建 Azure Cosmos 数据库。

步骤 5:创建容器

警告

方法 CreateContainerIfNotExistsAsync 创建新的容器,牵涉到定价。 有关详细信息,请访问 定价页

可以使用 CosmosDatabase 类中的 CreateContainerIfNotExistsAsyncCreateContainerAsync 方法创建容器。 容器包含项(在使用 SQL API 的情况下为 JSON 文档)和关联的 JavaScript 服务器端应用程序逻辑,例如存储过程、用户定义的函数以及触发器。

  1. 复制 CreateContainerAsync 方法并将其粘贴到 CreateDatabaseAsync 方法下面。 CreateContainerAsync 使用 containerId 字段中指定的 ID FamilyContainer 来创建按 LastName 属性分区的新容器(如果尚不存在该容器)。

    /// <summary>
    /// Create the container if it does not exist. 
    /// Specifiy "/LastName" as the partition key since we're storing family information, to ensure good distribution of requests and storage.
    /// </summary>
    /// <returns></returns>
    private async Task CreateContainerAsync()
    {
        // Create a new container
        this.container = await this.database.CreateContainerIfNotExistsAsync(containerId, "/LastName");
        Console.WriteLine("Created Container: {0}\n", this.container.Id);
    }
    
    
  2. 复制并粘贴以下代码,其中实例化了 CosmosClient 来调用刚添加的 CreateContainer 方法。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.CreateContainerAsync();
    }
    
  3. 选择 F5 来运行应用程序。

祝贺你! 你已成功创建 Azure Cosmos 容器。

步骤 6:向容器添加项

CosmosContainer 类的 CreateItemAsync 方法可以创建项。 使用 SQL API 时,项会投射为文档,后者是用户定义的任意 JSON 内容。 现在,可以将项插入 Azure Cosmos 容器中。

在此示例中,让我们首先创建 Family 类来表示存储在 Azure Cosmos DB 中的对象。 我们还会创建在 Family 中使用的 ParentChildPetAddress 子类。 该项必须有一个以 JSON 格式序列化为 idId 属性。

  1. 选择 Ctrl+Shift+A,打开“添加新项”。 将新类 Family.cs 添加到项目。

    Screenshot of adding a new Family.cs class into the project

  2. 复制 FamilyParentChildPetAddress 类并将其粘贴到 Family.cs 中。

    using Newtonsoft.Json;
    
    namespace CosmosGettingStartedTutorial
    {
        public class Family
        {
            [JsonProperty(PropertyName = "id")]
            public string Id { get; set; }
            public string LastName { get; set; }
            public Parent[] Parents { get; set; }
            public Child[] Children { get; set; }
            public Address Address { get; set; }
            public bool IsRegistered { get; set; }
            public override string ToString()
            {
                return JsonConvert.SerializeObject(this);
            }
        }
    
        public class Parent
        {
            public string FamilyName { get; set; }
            public string FirstName { get; set; }
        }
    
        public class Child
        {
            public string FamilyName { get; set; }
            public string FirstName { get; set; }
            public string Gender { get; set; }
            public int Grade { get; set; }
            public Pet[] Pets { get; set; }
        }
    
        public class Pet
        {
            public string GivenName { get; set; }
        }
    
        public class Address
        {
            public string State { get; set; }
            public string County { get; set; }
            public string City { get; set; }
        }
    }
    
  3. 回到 Program.cs 中,将 AddItemsToContainerAsync 方法添加到 CreateContainerAsync 方法后面。

    /// <summary>
    /// Add Family items to the container
    /// </summary>
    private async Task AddItemsToContainerAsync()
    {
        // Create a family object for the Andersen family
        Family andersenFamily = new Family
        {
            Id = "Andersen.1",
            LastName = "Andersen",
            Parents = new Parent[]
            {
                new Parent { FirstName = "Thomas" },
                new Parent { FirstName = "Mary Kay" }
            },
            Children = new Child[]
            {
                new Child
                {
                    FirstName = "Henriette Thaulow",
                    Gender = "female",
                    Grade = 5,
                    Pets = new Pet[]
                    {
                        new Pet { GivenName = "Fluffy" }
                    }
                }
            },
            Address = new Address { State = "WA", County = "King", City = "Seattle" },
            IsRegistered = false
        };
    
        try
        {
            // Read the item to see if it exists.  
            ItemResponse<Family> andersenFamilyResponse = await this.container.ReadItemAsync<Family>(andersenFamily.Id, new PartitionKey(andersenFamily.LastName));
            Console.WriteLine("Item in database with id: {0} already exists\n", andersenFamilyResponse.Resource.Id);
        }
        catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
        {
            // Create an item in the container representing the Andersen family. Note we provide the value of the partition key for this item, which is "Andersen"
            ItemResponse<Family> andersenFamilyResponse = await this.container.CreateItemAsync<Family>(andersenFamily, new PartitionKey(andersenFamily.LastName));
    
            // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
            Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", andersenFamilyResponse.Resource.Id, andersenFamilyResponse.RequestCharge);
        }
    
        // Create a family object for the Wakefield family
        Family wakefieldFamily = new Family
        {
            Id = "Wakefield.7",
            LastName = "Wakefield",
            Parents = new Parent[]
            {
                new Parent { FamilyName = "Wakefield", FirstName = "Robin" },
                new Parent { FamilyName = "Miller", FirstName = "Ben" }
            },
            Children = new Child[]
            {
                new Child
                {
                    FamilyName = "Merriam",
                    FirstName = "Jesse",
                    Gender = "female",
                    Grade = 8,
                    Pets = new Pet[]
                    {
                        new Pet { GivenName = "Goofy" },
                        new Pet { GivenName = "Shadow" }
                    }
                },
                new Child
                {
                    FamilyName = "Miller",
                    FirstName = "Lisa",
                    Gender = "female",
                    Grade = 1
                }
            },
            Address = new Address { State = "NY", County = "Manhattan", City = "NY" },
            IsRegistered = true
        };
    
        try
        {
            // Read the item to see if it exists
            ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>(wakefieldFamily.Id, new PartitionKey(wakefieldFamily.LastName));
            Console.WriteLine("Item in database with id: {0} already exists\n", wakefieldFamilyResponse.Resource.Id);
        }
        catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
        {
            // Create an item in the container representing the Wakefield family. Note we provide the value of the partition key for this item, which is "Wakefield"
            ItemResponse<Family> wakefieldFamilyResponse = await this.container.CreateItemAsync<Family>(wakefieldFamily, new PartitionKey(wakefieldFamily.LastName));
    
            // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
            Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", wakefieldFamilyResponse.Resource.Id, wakefieldFamilyResponse.RequestCharge);
        }
    }
    
    

    代码会进行检查,确保不存在 ID 相同的项。 我们会插入两个项,Andersen 家族和 Wakefield 家族各一个。

  4. GetStartedDemoAsync 方法中添加对 AddItemsToContainerAsync 的调用。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.AddItemsToContainerAsync();
    }
    
  5. 选择 F5 来运行应用程序。

祝贺你! 你已成功创建两个 Azure Cosmos 项。

步骤 7:查询 Azure Cosmos DB 资源

Azure Cosmos DB 支持对存储在每个容器中的 JSON 文档进行各种查询。 有关详细信息,请参阅 SQL 查询入门。 以下示例代码演示了如何针对我们在上一步插入的项来运行查询。

  1. 复制 QueryItemsAsync 方法,并将其粘贴到 AddItemsToContainerAsync 方法后面。

    /// <summary>
    /// Run a query (using Azure Cosmos DB SQL syntax) against the container
    /// </summary>
    private async Task QueryItemsAsync()
    {
        var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";
    
        Console.WriteLine("Running query: {0}\n", sqlQueryText);
    
        QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
        FeedIterator<Family> queryResultSetIterator = this.container.GetItemQueryIterator<Family>(queryDefinition);
    
        List<Family> families = new List<Family>();
    
        while (queryResultSetIterator.HasMoreResults)
        {
            FeedResponse<Family> currentResultSet = await queryResultSetIterator.ReadNextAsync();
            foreach (Family family in currentResultSet)
            {
                families.Add(family);
                Console.WriteLine("\tRead {0}\n", family);
            }
        }
    }
    
    
  2. GetStartedDemoAsync 方法中添加对 QueryItemsAsync 的调用。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.QueryItemsAsync();
    }
    
  3. 选择 F5 来运行应用程序。

祝贺你! 你已成功查询 Azure Cosmos 容器。

步骤 8:替换 JSON 项

现在,我们将更新 Azure Cosmos DB 中的一个项。 我们将更改 FamilyIsRegistered 属性以及某个孩子的 Grade

  1. 复制 ReplaceFamilyItemAsync 方法,并将其粘贴到 QueryItemsAsync 方法后面。

    /// <summary>
    /// Replace an item in the container
    /// </summary>
    private async Task ReplaceFamilyItemAsync()
    {
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>("Wakefield.7", new PartitionKey("Wakefield"));
        var itemBody = wakefieldFamilyResponse.Resource;
    
        // update registration status from false to true
        itemBody.IsRegistered = true;
        // update grade of child
        itemBody.Children[0].Grade = 6;
    
        // replace the item with the updated content
        wakefieldFamilyResponse = await this.container.ReplaceItemAsync<Family>(itemBody, itemBody.Id, new PartitionKey(itemBody.LastName));
        Console.WriteLine("Updated Family [{0},{1}].\n \tBody is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Resource);
    }
    
    
  2. GetStartedDemoAsync 方法中添加对 ReplaceFamilyItemAsync 的调用。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.ReplaceFamilyItemAsync();
    }
    
  3. 选择 F5 来运行应用程序。

祝贺你! 你已成功替换 Azure Cosmos 项。

步骤 9:删除项目

现在,我们将删除 Azure Cosmos DB 中的一个项。

  1. 复制 DeleteFamilyItemAsync 方法,并将其粘贴到 ReplaceFamilyItemAsync 方法后面。

    /// <summary>
    /// Delete an item in the container
    /// </summary>
    private async Task DeleteFamilyItemAsync()
    {
        var partitionKeyValue = "Wakefield";
        var familyId = "Wakefield.7";
    
        // Delete an item. Note we must provide the partition key value and id of the item to delete
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.DeleteItemAsync<Family>(familyId,new PartitionKey(partitionKeyValue));
        Console.WriteLine("Deleted Family [{0},{1}]\n", partitionKeyValue, familyId);
    }
    
    
  2. GetStartedDemoAsync 方法中添加对 DeleteFamilyItemAsync 的调用。

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
        await this.ReplaceFamilyItemAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.DeleteFamilyItemAsync();
    }
    
  3. 选择 F5 来运行应用程序。

祝贺你! 你已成功删除 Azure Cosmos 项。

步骤 10:删除数据库

现在,我们将删除数据库。 删除已创建的数据库会删除该数据库及其所有子资源。 这些资源包括容器、项、任何存储过程、用户定义的函数以及触发器。 我们还释放 CosmosClient 实例。

  1. 复制 DeleteDatabaseAndCleanupAsync 方法,并将其粘贴到 DeleteFamilyItemAsync 方法后面。

    /// <summary>
    /// Delete the database and dispose of the Cosmos Client instance
    /// </summary>
    private async Task DeleteDatabaseAndCleanupAsync()
    {
        DatabaseResponse databaseResourceResponse = await this.database.DeleteAsync();
        // Also valid: await this.cosmosClient.Databases["FamilyDatabase"].DeleteAsync();
    
        Console.WriteLine("Deleted Database: {0}\n", this.databaseId);
    
        //Dispose of CosmosClient
        this.cosmosClient.Dispose();
    }
    
    
  2. GetStartedDemoAsync 方法中添加对 DeleteDatabaseAndCleanupAsync 的调用。

    /// <summary>
    /// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
    /// </summary>
    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
        await this.ReplaceFamilyItemAsync();
        await this.DeleteFamilyItemAsync();
        await this.DeleteDatabaseAndCleanupAsync();
    }
    
    
  3. 选择 F5 来运行应用程序。

祝贺你! 你已成功删除 Azure Cosmos 数据库。

步骤 11:一起运行 C# 控制台应用程序!

在 Visual Studio 中选择 F5,即可在调试模式下生成并运行应用程序。

应会在控制台窗口中看到整个应用的输出。 输出会显示我们添加的查询的结果, 并且应与下面的示例文本相符。

Beginning operations...

Created Database: FamilyDatabase

Created Container: FamilyContainer

Created item in database with id: Andersen.1 Operation consumed 11.43 RUs.

Created item in database with id: Wakefield.7 Operation consumed 14.29 RUs.

Running query: SELECT * FROM c WHERE c.LastName = 'Andersen'

        Read {"id":"Andersen.1","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":5,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":false}

Updated Family [Wakefield,Wakefield.7].
        Body is now: {"id":"Wakefield.7","LastName":"Wakefield","Parents":[{"FamilyName":"Wakefield","FirstName":"Robin"},{"FamilyName":"Miller","FirstName":"Ben"}],"Children":[{"FamilyName":"Merriam","FirstName":"Jesse","Gender":"female","Grade":6,"Pets":[{"GivenName":"Goofy"},{"GivenName":"Shadow"}]},{"FamilyName":"Miller","FirstName":"Lisa","Gender":"female","Grade":1,"Pets":null}],"Address":{"State":"NY","County":"Manhattan","City":"NY"},"IsRegistered":true}

Deleted Family [Wakefield,Wakefield.7]

Deleted Database: FamilyDatabase

End of demo, press any key to exit.

祝贺你! 已经完成了本教程,并且获得了一个正常工作的 C# 控制台应用程序!

获取完整的教程解决方案

如果没有时间完成本教程中的步骤,或者只需下载代码示例,则可下载这些示例。

若要生成 GetStarted 解决方案,需要具备以下先决条件:

若要在 Visual Studio 中还原对 Azure Cosmos DB .NET SDK 的引用,请在解决方案资源管理器中右键单击此解决方案,然后选择“还原 NuGet 包” 。 接下来,在 App.config 文件中更新 EndPointUriPrimaryKey 值,如步骤 3:连接到 Azure Cosmos DB 帐户所述。

就这么简单,生成以后即可开始操作!

后续步骤