Tutorial: Construa uma aplicação de consola .NET para gerir dados na conta AZure Cosmos DB SQL API

APLICA-SE A: SQL API

Bem-vindos ao Azure Cosmos DB SQL API começam a tutorial. Depois de seguir este tutorial, terá de uma aplicação de consola que cria e consulta recursos do Cosmos DB.

Este tutorial utiliza a versão 3.0 ou mais tarde do Azure Cosmos DB .NET SDK. Pode trabalhar com .NET Framework ou .NET Core.

Este tutorial aborda:

  • Criar e conectar-se a uma conta Azure Cosmos
  • Configurar o seu projeto no Visual Studio
  • Criação de uma base de dados e um contentor
  • Adicionar itens ao contentor
  • Consulta o contentor
  • Realizar operações de criação, leitura, atualização e eliminação (CRUD) no item
  • Eliminar a base de dados

Não tem tempo? Não se preocupe! A solução completa está disponível em GitHub. Salte para a secção Obter a solução tutorial completa para obter instruções rápidas.

Agora comecemos!

Pré-requisitos

Passo 1: Criar uma conta do Azure Cosmos DB

Vamos criar uma conta do Azure Cosmos DB. Se já tem uma conta que pretende utilizar, ignore esta secção. Para utilizar o Emulador Azure Cosmos DB, siga os passos no Azure Cosmos DB Emulator para configurar o emulador. Em seguida, avance para o Passo 2: Crie o seu projeto Visual Studio.

  1. A partir do menu do portal Azure ou da página Inicial, selecione Criar um recurso.

  2. Na página Nova, procure e selecione Azure Cosmos DB.

  3. Na página DB do Azure Cosmos, selecione Criar.

  4. Na página De Conta DB Create Azure Cosmos, insira as definições básicas para a nova conta Azure Cosmos.

    Definição Valor Descrição
    Subscrição Nome da subscrição Selecione a subscrição do Azure que quer utilizar para esta conta do Azure Cosmos.
    Grupo de Recursos Nome do grupo de recursos Selecione um grupo de recursos ou selecione Criar novo e, em seguida, introduza um nome exclusivo para o novo grupo de recursos.
    Nome da Conta Um nome exclusivo Introduza um nome para identificar a conta do Azure Cosmos. Uma vez que documents.azure.com é anexado ao nome que indicar para criar o URI, utilize um nome exclusivo.

    O nome só pode conter letras minúsculas, números e o caráter de hífen (-). Deve ter entre 3 a 44 caracteres de comprimento.
    API O tipo de conta a criar Selecione Núcleo (SQL) para criar uma base de dados de documentos e consultar com a sintaxe SQL.

    A API determina o tipo de conta a criar. A Azure Cosmos DB fornece cinco APIs: Core (SQL) e MongoDB para dados de documentos, Gremlin para dados gráficos, Tabela Azure e Cassandra. De momento, deve criar uma conta separada para cada API.

    Saiba mais sobre a API SQL.
    Localização A região mais próxima dos seus utilizadores Selecione a localização geográfica para alojar a sua conta do Azure Cosmos DB. Utilize a localização mais próxima dos utilizadores para lhes dar o acesso mais rápido aos dados.
    Modo de capacidade Produção provisida ou sem servidor Selecione Provisão para criar uma conta no modo de produção previsto. Selecione Serverless para criar uma conta no modo sem servidor.
    Aplicar desconto de nível gratuito Azure Cosmos DB Aplicar ou não aplicar Com o nível livre Azure Cosmos DB, você receberá os primeiros 1000 RU/s e 25 GB de armazenamento gratuitamente numa conta. Saiba mais sobre o free tier.

    Nota

    Pode ter até uma conta DB Azure Cosmos de nível gratuito por subscrição Azure e deve optar pela criação da conta. Se não vir a opção de aplicar o desconto de nível livre, isto significa que outra conta na subscrição já foi ativada com nível gratuito.

    A página de nova conta do Azure Cosmos DB

  5. No separador Distribuição Global, configuure os seguintes detalhes. Pode deixar os valores predefinidos para efeitos deste arranque rápido:

    Definição Valor Descrição
    Redundância Geográfica Desativar Ativar ou desativar a distribuição global na sua conta, emparelhando a sua região com uma região de pares. Pode adicionar mais regiões à sua conta mais tarde.
    Escritas de várias regiões Desativar A capacidade de escrita multi-região permite-lhe tirar partido da produção prevista para as suas bases de dados e contentores em todo o mundo.

    Nota

    As seguintes opções não estão disponíveis se selecionar Serverless como o modo Capacidade:

    • Aplicar Desconto de Escalão Gratuito
    • Georredundância
    • Escritas de várias regiões
  6. Opcionalmente, pode configurar detalhes adicionais nos seguintes separadores:

    • Networking - Configurar o acesso a partir de uma rede virtual.
    • Política de Backup - Configurar uma política de backup periódica ou contínua.
    • Encriptação - Utilize uma chave gerida pelo serviço ou uma chave gerida pelo cliente.
    • Tags - Tags são pares de nome/valor que lhe permitem categorizar recursos e visualizar faturação consolidada aplicando a mesma etiqueta a múltiplos recursos e grupos de recursos.
  7. Selecione Rever + criar.

  8. Reveja as definições da conta e, em seguida, selecione Criar. A criação da conta demora alguns minutos. Aguarde até que a página do portal apresente A implementação está concluída.

    O painel Notificações do portal do Azure

  9. Selecione Ir para recurso para aceder à página da conta do Azure Cosmos DB.

    A página da conta do Azure Cosmos DB

Passo 2: Crie o seu projeto Visual Studio

  1. Abra o Estúdio Visual e selecione Criar um novo projeto.

  2. In Create a new project, escolha App consola (.NET Framework) para C#e, em seguida, selecione Next.

  3. Nomeie o seu projeto CosmosGettingStartedTutorial e, em seguida, selecione Create.

    Configure o seu projeto

  4. No Solution Explorer, clique com o botão direito na sua nova aplicação de consola, que está sob a sua solução Visual Studio, e selecione Gerir Pacotes NuGet.

  5. No Gestor de Pacotes NuGet, selecione Procurar microsoft.Azure.Cosmos. Escolha Microsoft.Azure.Cosmos e selecione Instalar.

    Instalar o NuGet para a Azure Cosmos DB Client SDK

    O ID do pacote para a Biblioteca de Cliente da API SQL do Azure Cosmos DB é Biblioteca de Cliente do Microsoft Azure Cosmos DB.

Excelente! Agora que concluímos a configuração, comecemos a escrever certos códigos. Para o projeto concluído deste tutorial, consulte desenvolver uma aplicação de consola .NET utilizando a Azure Cosmos DB.

Passo 3: Ligar a uma conta do Azure Cosmos DB

  1. Substitua as referências no início da sua aplicação C# no ficheiro .cs Programa por estas referências:

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
  2. Adicione estas constantes e variáveis na sua Program classe.

    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";
    }
    

    Nota

    Se estiver familiarizado com a versão anterior do .NET SDK, poderá estar familiarizado com a recolha e documento dos termos. Uma vez que a Azure Cosmos DB suporta vários modelos API, a versão 3.0 do .NET SDK utiliza o recipiente e o item genéricos . Um recipiente pode ser uma coleção, gráfico ou mesa. Um item pode ser um documento, borda/vértice, ou linha, e é o conteúdo dentro de um recipiente. Para obter mais informações, consulte Trabalhar com bases de dados, contentores e itens em Azure Cosmos DB.

  3. Abra o portal do Azure. Encontre a sua conta DB Azure Cosmos e, em seguida, selecione Keys.

    Obtenha as chaves DB do Azure Cosmos do portal Azure

  4. No Programa.cs, <your endpoint URL> substitua-o pelo valor da URI. <your primary key>Substitua-o pelo valor da CHAVE PRIMÁRIA.

  5. Abaixo do método Principal, adicione uma nova tarefa assíncronea chamada GetStartedDemoAsync, que instantaneamente o nosso novo 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);
    }
    

    Utilizamos o GetStartedDemoAsync como o ponto de entrada que chama métodos que operam nos recursos DB da Azure Cosmos.

  6. Adicione o seguinte código para executar a tarefa assíncron GetStartedDemoAsync do seu método Principal. O método Principal captura as exceções e escreve-as na consola.

    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. Selecione F5 para executar a sua aplicação.

    A consola exibe a mensagem: Fim da demonstração, prima qualquer tecla para sair. Esta mensagem confirma que a sua aplicação fez uma ligação ao Azure Cosmos DB. Em seguida, pode fechar a janela da consola.

Parabéns! Ligaste-te com sucesso a uma conta DB da Azure Cosmos.

Passo 4: Criar uma base de dados

As bases de dados são os contentores lógicos dos itens particionados em contentores. Ou o CreateDatabaseIfNotExistsAsync método ou método da classe CreateDatabaseAsync CosmosClient pode criar uma base de dados.

  1. Copie e cole o CreateDatabaseAsync método abaixo do seu GetStartedDemoAsync método.

    /// <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 cria uma nova base de dados com ID FamilyDatabase se já não existir, que tem o ID especificado a partir do databaseId campo.

  2. Copie e cole o código abaixo onde instantaneamente o CosmosClient para ligar para o método CreateDatabaseAsync que acaba de adicionar.

    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();
    }
    

    O seu programa.cs deve agora ser assim, com o seu ponto final e a chave primária preenchidas.

    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. Selecione F5 para executar a sua aplicação.

    Nota

    Se obtém um erro de "exceção indisponíveis de serviço 503", é possível que as portas necessárias para o modo de conectividade direta sejam bloqueadas por uma firewall. Para corrigir este problema, abra as portas necessárias ou utilize a conectividade do modo gateway, como indicado no seguinte código:

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

Parabéns! Criou com sucesso uma base de dados da Azure Cosmos.

Passo 5: Criar um recipiente

Aviso

O método CreateContainerIfNotExistsAsync cria um novo recipiente, que tem implicações nos preços. Para mais detalhes, visite a nossa página de preços.

Um recipiente pode ser criado utilizando o método CreateContainerIfNotExistsAsync ou CreateContainerAsync na CosmosDatabase classe. Um recipiente é composto por itens (documentos JSON se SQL API) e lógica de aplicação associada do lado do servidor no JavaScript, por exemplo, procedimentos armazenados, funções definidas pelo utilizador e gatilhos.

  1. Copie e cole o CreateContainerAsync método abaixo do seu CreateDatabaseAsync método. CreateContainerAsync cria um novo recipiente com o ID FamilyContainer se já não existir, utilizando o ID especificado a partir do containerId campo dividido por LastName propriedade.

    /// <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. Copie e cole o código abaixo onde instantaneamente o CosmosClient para chamar o método CreateContainer que acaba de adicionar.

    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. Selecione F5 para executar a sua aplicação.

Parabéns! Criou com sucesso um contentor Azure Cosmos.

Passo 6: Adicione itens ao recipiente

O método CreateItemAsync da CosmosContainer classe pode criar um item. Ao utilizar a API SQL, os itens são projetados como documentos, que são conteúdo arbitrário JSON definido pelo utilizador. Pode agora inserir um item no seu recipiente Azure Cosmos.

Primeiro, vamos criar uma Family classe que represente objetos armazenados dentro da Azure Cosmos DB nesta amostra. Também criaremos Parent Child Pet Address subclasses que são usadas dentro Family de . O item deve ter uma Id propriedade serializada como id em JSON.

  1. Selecione Ctrl+Shift+A para abrir Adicionar Novo Item. Adicione uma nova classe Family.cs ao seu projeto.

    Screenshot de adicionar uma nova classe .cs família no projeto

  2. Copiar e colar Family Parent o, Child , , e classe em Pet Address 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. De volta ao Programa.cs, adicione o AddItemsToContainerAsync método após o seu CreateContainerAsync método.

    /// <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);
        }
    }
    

    O código verifica se um item com a mesma identificação já não existe. Vamos inserir dois itens, um para a Família Andersen e para a Família Wakefield.

  4. Adicione uma chamada para AddItemsToContainerAsync o GetStartedDemoAsync método.

    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. Selecione F5 para executar a sua aplicação.

Parabéns! Criou com sucesso dois itens da Azure Cosmos.

Passo 7: Consultar recursos do Azure Cosmos DB

O Azure Cosmos DB suporta consultas extensas em documentos JSON armazenados em cada contentor. Para mais informações, consulte Começar com consultas SQL. O seguinte código de amostra mostra como executar uma consulta contra os itens que inserimos no passo anterior.

  1. Copie e cole o QueryItemsAsync método após o seu AddItemsToContainerAsync método.

    /// <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. Adicione uma chamada para QueryItemsAsync o GetStartedDemoAsync método.

    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. Selecione F5 para executar a sua aplicação.

Parabéns! Perguntaste com sucesso um contentor do Azure Cosmos.

Passo 8: Substituir um item JSON

Agora, vamos atualizar um artigo no Azure Cosmos DB. Mudaremos a IsRegistered propriedade de Family uma das Grade crianças.

  1. Copie e cole o ReplaceFamilyItemAsync método após o seu QueryItemsAsync método.

    /// <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. Adicione uma chamada para ReplaceFamilyItemAsync o GetStartedDemoAsync método.

    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. Selecione F5 para executar a sua aplicação.

Parabéns! Substituiste com sucesso um artigo da Azure Cosmos.

Passo 9: Eliminar item

Agora, vamos apagar um item em Azure Cosmos DB.

  1. Copie e cole o DeleteFamilyItemAsync método após o seu ReplaceFamilyItemAsync método.

    /// <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. Adicione uma chamada para DeleteFamilyItemAsync o GetStartedDemoAsync método.

    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. Selecione F5 para executar a sua aplicação.

Parabéns! Apagou com sucesso um artigo da Azure Cosmos.

Passo 10: Eliminar a base de dados

Agora vamos apagar a nossa base de dados. A eliminação da base de dados criada remove a base de dados e todos os recursos para crianças. Os recursos incluem contentores, itens e quaisquer procedimentos armazenados, funções definidas pelo utilizador e gatilhos. Também dispomos do CosmosClient caso.

  1. Copie e cole o DeleteDatabaseAndCleanupAsync método após o seu DeleteFamilyItemAsync método.

    /// <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. Adicione uma chamada para DeleteDatabaseAndCleanupAsync o GetStartedDemoAsync método.

    /// <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. Selecione F5 para executar a sua aplicação.

Parabéns! Apagou com sucesso uma base de dados da Azure Cosmos.

Passo 11: Executar a sua aplicação de consola C# em conjunto!

Selecione F5 no Estúdio Visual para construir e executar a aplicação no modo depuramento.

Você deve ver a saída de toda a sua aplicação em uma janela de consola. A saída mostra os resultados das consultas que adicionámos. Deve corresponder ao texto de exemplo abaixo.

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.

Parabéns! Concluiu este tutorial e a sua aplicação de consola C# está a funcionar!

Obter a solução completa do tutorial

Se não teve tempo de completar os passos deste tutorial, ou apenas quiser descarregar as amostras de código, pode descarregá-lo.

Para construir a GetStarted solução, precisa dos seguintes pré-requisitos:

Para restaurar as referências ao Azure Cosmos DB .NET SDK no Visual Studio, clique com o botão direito na solução no Solution Explorer e, em seguida, selecione Restore NuGet Packages. Em seguida, no ficheiro App.config, atualize os EndPointUri PrimaryKey valores descritos no Passo 3: Ligue-se a uma conta DB Azure Cosmos.

É isso, constrói-o e estás a caminho!

Passos seguintes