Introdução à API de Tabela do Azure Cosmos DB e armazenamento de Tabelas do Azure usando SDK do .NETGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

Dica

O conteúdo deste artigo se aplica ao armazenamento de Tabelas do Azure e à API de Tabelas do Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. A API de Tabelas do Azure Cosmos DB é uma oferta premium para o armazenamento de tabelas que oferece tabelas com otimização de taxa de transferência, distribuição global e índices secundários automáticos.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

É possível usar a API de Tabela do Azure Cosmos DB ou o armazenamento de Tabelas do Azure para armazenar dados NoSQL estruturados na nuvem, fornecendo um repositório de chave/atributo com um esquema sem design.You can use the Azure Cosmos DB Table API or Azure Table storage to store structured NoSQL data in the cloud, providing a key/attribute store with a schema less design. Como a API de Tabela do Azure Cosmos DB e o armazenamento de Tabelas são sem esquema, é fácil adaptar seus dados à medida que as necessidades do aplicativo evoluem.Because Azure Cosmos DB Table API and Table storage are schema less, it's easy to adapt your data as the needs of your application evolve. É possível usar a API de Tabela do Azure Cosmos DB e o armazenamento de Tabelas para armazenar conjuntos de dados flexíveis como dados de usuário para aplicativos Web, catálogos de endereços, informações de dispositivo ou outros tipos de metadados que o serviço exigir.You can use Azure Cosmos DB Table API or the Table storage to store flexible datasets such as user data for web applications, address books, device information, or other types of metadata your service requires.

Este tutorial descreve um exemplo que mostra como usar a Biblioteca de Tabelas do Microsoft Azure Cosmos DB para .NET com cenários de API de Tabela do Azure Cosmos DB e armazenamento de Tabelas do Azure.This tutorial describes a sample that shows you how to use the Microsoft Azure Cosmos DB Table Library for .NET with Azure Cosmo DB Table API and Azure Table storage scenarios. Você deverá usar a conexão específica para o serviço do Azure.You must use the connection specific to the Azure service. Esses cenários são explorados usando exemplos em C# que ilustram como criar tabelas, inserir/atualizar dados, consultar dados e excluir tabelas.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

Pré-requisitosPrerequisites

Você precisará do seguinte para concluir este exemplo com sucesso:You need the following to complete this sample successfully:

Criar uma conta de API de Tabele do Azure Cosmos DBCreate an Azure Cosmos DB Table API account

  1. Em uma nova janela do navegador, entre no Portal do Azure.In a new browser window, sign in to the Azure portal.

  2. No painel de navegação esquerdo, selecione Criar um recurso.In the left navigation pane, select Create a resource. Selecione Bancos de dados e, em seguida, selecione Azure Cosmos DB.Select Databases and then select Azure Cosmos DB.

    Captura de tela do portal do Azure, realçando Mais Serviços e Azure Cosmos DB

  3. Na página Criar Conta do Azure Cosmos DB, insira as configurações da nova conta do Azure Cosmos DB:On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account:

    ConfiguraçãoSetting ValorValue DESCRIÇÃODescription
    AssinaturaSubscription Sua assinaturaYour subscription Selecione a assinatura do Azure que você deseja usar para essa conta do Azure Cosmos DB.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    Grupo de recursosResource Group Criar NovoCreate new

    Em seguida, insira o mesmo nome exclusivo fornecido na IDThen enter the same unique name as provided in ID
    Selecione Criar novo.Select Create new. Em seguida, insira um novo nome de grupo de recursos para a conta.Then enter a new resource group name for your account. Para simplificar, use um nome igual à sua ID.For simplicity, use the same name as your ID.
    Nome da contaAccount Name Insira um nome exclusivoEnter a unique name Insira um nome exclusivo para identificar a conta do Azure Cosmos DB.Enter a unique name to identify your Azure Cosmos DB account.

    A ID deve conter apenas letras minúsculas, números e o caractere de hífen (-).The ID can use only lowercase letters, numbers, and the hyphen (-) character. Deve ter entre 3 e 31 caracteres.It must be between 3 and 31 characters long.
    APIAPI tabela do AzureAzure Table A API determina o tipo de conta a ser criada.The API determines the type of account to create. O Azure Cosmos DB fornece cinco APIs: Core(SQL) para bancos de dados de documentos, Gremlin para o bancos de dados de grafos, MongoDB para bancos de dados de documentos, Tabela do Azure e Cassandra.Azure Cosmos DB provides five APIs: Core(SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. No momento, você deve criar uma conta separada para cada API.Currently, you must create a separate account for each API.

    Selecione Tabela do Azure porque neste início rápido você está criando uma tabela que funciona com a API de Tabela.Select Azure Table because in this quickstart you're creating a table that works with the Table API.

    Saiba mais sobre a API de Tabela.Learn more about the Table API.
    Local padrãoLocation Selecione a região mais próxima de seus usuáriosSelect the region closest to your users Selecione uma localização geográfica para hospedar a sua conta do Azure Cosmos DB.Select a geographic location to host your Azure Cosmos DB account. Use a localização mais próxima dos usuários para fornecer a eles acesso mais rápido aos dados.Use the location that's closest to your users to give them the fastest access to data.

    Você pode manter as opções Replicação Geográfica e Gravações de Várias Regiões com os valores padrão (Desabilitar) para evitar encargos de RU adicionais.You can leave the Geo-Redundancy and Multi-region Writes options at their default values (Disable) to avoid additional RU charges. Você pode ignorar as seções Rede e Marcas.You can skip the Network and Tags sections.

  4. Selecione Revisar + Criar.Select Review+Create. Após a concluir a validação, selecione Criar para criar a conta.After the validation is complete, select Create to create the account.

    A página da nova conta do Azure Cosmos DB

  5. São necessários alguns minutos para criar a conta.It takes a few minutes to create the account. Um mensagem informando A implantação está em andamento será exibida.You'll see a message that states Your deployment is underway. Aguarde a conclusão da implantação e selecione Ir para o recurso.Wait for the deployment to finish and then select Go to resource.

    O painel de notificações do portal do Azure

Criar um projeto de console do .NETCreate a .NET console project

No Visual Studio, crie um novo aplicativo de console do .NET.In Visual Studio, create a new .NET console application. As etapas a seguir mostram como criar um aplicativo de console no Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. É possível usar a Biblioteca de Tabelas do Azure Cosmos DB em qualquer tipo de aplicativo .NET, incluindo um serviço de nuvem do Azure ou um aplicativo Web, além de aplicativos para área de trabalho e dispositivos móveis.You can use the Azure Cosmos DB Table Library in any type of .NET application, including an Azure cloud service or web app, and desktop and mobile applications. Neste guia, usamos um aplicativo de console para simplificar.In this guide, we use a console application for simplicity.

  1. Selecione Arquivo > Novo > Projeto.Select File > New > Project.

  2. Escolha Aplicativo de Console (.NET Core) e, em seguida, selecione Avançar.Choose Console App (.NET Core), and then select Next.

  3. No campo Nome do projeto, insira um nome para seu aplicativo, por exemplo, CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. (Você pode fornecer um nome diferente conforme necessário.)(You can provide a different name as needed.)

  4. Selecione Criar.Select Create.

Todos os exemplos de código neste exemplo podem ser adicionados ao método Main() do arquivo Program.cs do aplicativo do console.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Instalar o pacote NuGet necessárioInstall the required NuGet package

Para obter o pacote NuGet, siga estas etapas:To obtain the NuGet package, follow these steps:

  1. Clique com o botão direito do mouse no seu projeto no Gerenciador de Soluções e escolha Gerenciar Pacotes NuGet.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Pesquise online por Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder e selecione Instalar para instalar a Biblioteca de Tabelas do Microsoft Azure Cosmos DB.Search online for Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder and select Install to install the Microsoft Azure Cosmos DB Table Library.

Configurar a cadeia de conexão de armazenamentoConfigure your storage connection string

  1. Do portal do Azure, navegue até sua conta do Azure Cosmos ou conta do Armazenamento de Tabelas.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Abra o painel Cadeia de Conexão ou Chaves de acesso painel.Open the Connection String or Access keys pane. Use o botão de cópia no lado direito da tela para copiar a CADEIA DE CONEXÃO PRIMÁRIA.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    Exiba e copie a CADEIA DE CONEXÃO PRIMÁRIA no painel Cadeia de Conexão

  3. Para configurar a cadeia de conexão, no Visual Studio clique com o botão direito do mouse no projeto CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Selecione Adicionar e, em seguida, Novo Item.Select Add and then New Item. Crie um novo arquivo Settings.json com o tipo de arquivo como Arquivo de Configuração JSON do TypeScript.Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Substitua o código no arquivo Settings.json pelo seguinte código e atribua a cadeia de conexão primária:Replace the code in Settings.json file with the following code and assign your primary connection string:

    {
    "StorageConnectionString": <Primary connection string of your Azure Cosmos DB account>
    }
    
  6. Clique com o botão direito do mouse no projeto CosmosTableSamples.Right click on your project CosmosTableSamples. Selecione Adicionar, Novo Item e adicione uma classe nomeada AppSettings.cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Adicione o seguinte código ao arquivo AppSettings.cs.Add the following code to the AppSettings.cs file. Esse arquivo lê a cadeia de conexão do arquivo Settings.json e a atribui ao parâmetro de configuração:This file reads the connection string from Settings.json file and assigns it to the configuration parameter:

    namespace CosmosTableSamples
    {
     using Microsoft.Extensions.Configuration;
     public class AppSettings
     {
         public string StorageConnectionString { get; set; }
         public static AppSettings LoadAppSettings()
         {
             IConfigurationRoot configRoot = new ConfigurationBuilder()
                 .AddJsonFile("Settings.json")
                 .Build();
             AppSettings appSettings = configRoot.Get<AppSettings>();
             return appSettings;
         }
     }
    }
    

Analisar e validar os detalhes da conexãoParse and validate the connection details

  1. Clique com o botão direito do mouse no projeto CosmosTableSamples.Right click on your project CosmosTableSamples. Selecione Adicionar, Novo Item e adicione uma classe nomeada Common.cs.Select Add, New Item and add a class named Common.cs. Você gravará código para validar os detalhes da conexão e criar uma tabela dentro dessa classe.You will write code to validate the connection details and create a table within this class.

  2. Defina um método CreateStorageAccountFromConnectionString, conforme mostrado abaixo.Define a method CreateStorageAccountFromConnectionString as shown below. Esse método analisará os detalhes da cadeia de conexão e validará se os detalhes da chave de conta e do nome da conta fornecidos no arquivo "Settings.json" são válidos.This method will parse the connection string details and validate that the account name and account key details provided in the "Settings.json" file are valid.

using System;

namespace CosmosTableSamples
{
   using System.Threading.Tasks;
   using Microsoft.Azure.Cosmos.Table;
   using Microsoft.Azure.Documents;

   public class Common
   {
       public static CloudStorageAccount CreateStorageAccountFromConnectionString(string storageConnectionString)
       {
           CloudStorageAccount storageAccount;
           try
           {
               storageAccount = CloudStorageAccount.Parse(storageConnectionString);
           }
           catch (FormatException)
           {
               Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the application.");
               throw;
           }
           catch (ArgumentException)
           {
               Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the sample.");
               Console.ReadLine();
               throw;
           }

           return storageAccount;
       }
   }
}

Criar uma tabelaCreate a Table

A classe CloudTableClient permite que você recupere as tabelas e entidades armazenadas no Armazenamento de tabelas.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Como não temos tabelas na conta de API de Tabela do Cosmos DB, adicionaremos o método CreateTableAsync para a classe Common.cs para criar uma tabela:Because we don’t have any tables in the Cosmos DB Table API account, let’s add the CreateTableAsync method to the Common.cs class to create a table:

public static async Task<CloudTable> CreateTableAsync(string tableName)
  {
    string storageConnectionString = AppSettings.LoadAppSettings().StorageConnectionString;

    // Retrieve storage account information from connection string.
    CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(storageConnectionString);

    // Create a table client for interacting with the table service
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient(new TableClientConfiguration());

    Console.WriteLine("Create a Table for the demo");

    // Create a table client for interacting with the table service 
    CloudTable table = tableClient.GetTableReference(tableName);
    if (await table.CreateIfNotExistsAsync())
    {
      Console.WriteLine("Created Table named: {0}", tableName);
    }
    else
    {
      Console.WriteLine("Table {0} already exists", tableName);
    }

    Console.WriteLine();
    return table;
}

Definir a entidadeDefine the entity

As entidades são mapeadas para objetos C# usando uma classe personalizada derivada de TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Para adicionar uma entidade a uma tabela, crie uma classe que defina as propriedades da sua entidade.To add an entity to a table, create a class that defines the properties of your entity.

Clique com o botão direito do mouse no projeto CosmosTableSamples.Right click on your project CosmosTableSamples. Selecione Adicionar, Nova Pasta e nomeie-a como Modelo.Select Add, New Folder and name it as Model. Na pasta Modelo, adicione uma classe nomeada CustomerEntity.cs e adicione o código a seguir.Within the Model folder add a class named CustomerEntity.cs and add the following code to it.

namespace CosmosTableSamples.Model
{
    using Microsoft.Azure.Cosmos.Table;
    public class CustomerEntity : TableEntity
    {
        public CustomerEntity()
        {
        }

        public CustomerEntity(string lastName, string firstName)
        {
            PartitionKey = lastName;
            RowKey = firstName;
        }

        public string Email { get; set; }
        public string PhoneNumber { get; set; }
    }
}

Esse código define uma classe de entidade que usa o nome do cliente como a chave de linha e o sobrenome como a chave de partição.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. Juntas, uma chave de partição e uma chave de linha identificam exclusivamente a entidade na tabela.Together, an entity's partition and row key uniquely identify it in the table. As entidades com a mesma chave de partição podem ser consultadas mais rápido do que aquelas com chaves de partição diferentes, mas usar chaves de partição diferentes permite uma escalabilidade maior de operações paralelas.Entities with the same partition key can be queried faster than entities with different partition keys but using diverse partition keys allows for greater scalability of parallel operations. As entidades que serão armazenadas em tabelas deverão ser de um tipo com suporte, por exemplo, derivado da classe TableEntity.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. As propriedades de entidade que você gostaria de armazenar em uma tabela precisam ser propriedades públicas do tipo e dar suporte à obtenção e à definição dos valores.Entity properties you'd like to store in a table must be public properties of the type, and support both getting and setting of values. Além disso, o tipo de entidade deverá expor um construtor sem parâmetros.Also, your entity type must expose a parameter-less constructor.

Inserir ou mesclar uma entidadeInsert or merge an entity

O exemplo de código a seguir cria um objeto de entidade e o adiciona à tabela.The following code example creates an entity object and adds it to the table. O método InsertOrMerge dentro da classe TableOperation é usado para inserir ou mesclar uma entidade.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. O método CloudTable.ExecuteAsync é chamado para executar a operação.The CloudTable.ExecuteAsync method is called to execute the operation.

Clique com o botão direito do mouse no projeto CosmosTableSamples.Right click on your project CosmosTableSamples. Selecione Adicionar, Novo Item e adicione uma classe nomeada SamplesUtils.cs.Select Add, New Item and add a class named SamplesUtils.cs. Essa classe armazena todo o código necessário para executar operações CRUD nas entidades.This class stores all the code required to perform CRUD operations on the entities.

public static async Task<CustomerEntity> InsertOrMergeEntityAsync(CloudTable table, CustomerEntity entity)
    {
      if (entity == null)
    {
       throw new ArgumentNullException("entity");
    }
    try
    {
       // Create the InsertOrReplace table operation
       TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(entity);

       // Execute the operation.
       TableResult result = await table.ExecuteAsync(insertOrMergeOperation);
       CustomerEntity insertedCustomer = result.Result as CustomerEntity;
        
        // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
        if (result.RequestCharge.HasValue)
          {
            Console.WriteLine("Request Charge of InsertOrMerge Operation: " + result.RequestCharge);
          }

        return insertedCustomer;
        }
        catch (StorageException e)
        {
          Console.WriteLine(e.Message);
          Console.ReadLine();
          throw;
        }
    }

Obter uma entidade de uma partiçãoGet an entity from a partition

É possível obter entidade de uma partição usando o método Recuperar na classe TableOperation.You can get entity from a partition by using the Retrieve method under the TableOperation class. O exemplo de código a seguir obtém a chave de linha da chave de partição, o email e o número de telefone de uma entidade do cliente.The following code example gets the partition key row key, email and phone number of a customer entity. Este exemplo também imprime as unidades de solicitação consumidas para consultar a entidade.This example also prints out the request units consumed to query for the entity. Para consultar uma entidade, acrescente o seguinte código ao arquivo SamplesUtils.cs:To query for an entity, append the following code to SamplesUtils.cs file:

public static async Task<CustomerEntity> RetrieveEntityUsingPointQueryAsync(CloudTable table, string partitionKey, string rowKey)
    {
      try
      {
        TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>(partitionKey, rowKey);
        TableResult result = await table.ExecuteAsync(retrieveOperation);
        CustomerEntity customer = result.Result as CustomerEntity;
        if (customer != null)
        {
          Console.WriteLine("\t{0}\t{1}\t{2}\t{3}", customer.PartitionKey, customer.RowKey, customer.Email, customer.PhoneNumber);
        }

        // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
        if (result.RequestCharge.HasValue)
        {
           Console.WriteLine("Request Charge of Retrieve Operation: " + result.RequestCharge);
        }

        return customer;
        }
        catch (StorageException e)
        {
           Console.WriteLine(e.Message);
           Console.ReadLine();
           throw;
        }
    }

Excluir uma entidadeDelete an entity

Você pode excluir facilmente uma entidade após a recuperação usando o mesmo padrão mostrado para a atualização de uma entidade.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. O código a seguir recupera e exclui uma entidade de cliente.The following code retrieves and deletes a customer entity. Para excluir uma entidade, anexe o seguinte código ao arquivo SamplesUtils.cs:To delete an entity, append the following code to SamplesUtils.cs file:

public static async Task DeleteEntityAsync(CloudTable table, CustomerEntity deleteEntity)
   {
     try
     {
        if (deleteEntity == null)
     {
        throw new ArgumentNullException("deleteEntity");
     }

    TableOperation deleteOperation = TableOperation.Delete(deleteEntity);
    TableResult result = await table.ExecuteAsync(deleteOperation);

    // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
    if (result.RequestCharge.HasValue)
    {
       Console.WriteLine("Request Charge of Delete Operation: " + result.RequestCharge);
    }

    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Executar as operações CRUD em dados de exemploExecute the CRUD operations on sample data

Após definir os métodos para criar tabela, inserir ou mesclar entidades, execute esses métodos nos dados de exemplo.After you define the methods to create table, insert or merge entities, run these methods on the sample data. Para fazer isso, clique com o botão direito do mouse no projeto CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Selecione Adicionar, Novo Item e adicione uma classe nomeada BasicSamples.cs, em seguida, adicione o seguinte código.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Esse código cria uma tabela e adiciona entidades a ela.This code creates a table, adds entities to it. Se você quiser excluir a entidade e a tabela no término do projeto, remova os comentários dos métodos table.DeleteIfExistsAsync() e SamplesUtils.DeleteEntityAsync(table, customer) do seguinte código:If you wish to delete the entity and table at the end of the project remove the comments from table.DeleteIfExistsAsync() and SamplesUtils.DeleteEntityAsync(table, customer) methods from the following code:

using System;
namespace CosmosTableSamples
{
    using System.Threading.Tasks;
    using Microsoft.Azure.Cosmos.Table;
    using Model;

    class BasicSamples
    {
        public async Task RunSamples()
        {
            Console.WriteLine("Azure Cosmos DB Table - Basic Samples\n");
            Console.WriteLine();

            string tableName = "demo" + Guid.NewGuid().ToString().Substring(0, 5);

            // Create or reference an existing table
            CloudTable table = await Common.CreateTableAsync(tableName);

            try
            {
                // Demonstrate basic CRUD functionality 
                await BasicDataOperationsAsync(table);
            }
            finally
            {
                // Delete the table
                // await table.DeleteIfExistsAsync();
            }
        }

        private static async Task BasicDataOperationsAsync(CloudTable table)
        {
            // Create an instance of a customer entity. See the Model\CustomerEntity.cs for a description of the entity.
            CustomerEntity customer = new CustomerEntity("Harp", "Walter")
            {
                Email = "Walter@contoso.com",
                PhoneNumber = "425-555-0101"
            };

            // Demonstrate how to insert the entity
            Console.WriteLine("Insert an Entity.");
            customer = await SamplesUtils.InsertOrMergeEntityAsync(table, customer);

            // Demonstrate how to Update the entity by changing the phone number
            Console.WriteLine("Update an existing Entity using the InsertOrMerge Upsert Operation.");
            customer.PhoneNumber = "425-555-0105";
            await SamplesUtils.InsertOrMergeEntityAsync(table, customer);
            Console.WriteLine();

            // Demonstrate how to Read the updated entity using a point query 
            Console.WriteLine("Reading the updated Entity.");
            customer = await SamplesUtils.RetrieveEntityUsingPointQueryAsync(table, "Harp", "Walter");
            Console.WriteLine();

            // Demonstrate how to Delete an entity
            //Console.WriteLine("Delete the entity. ");
            //await SamplesUtils.DeleteEntityAsync(table, customer);
            //Console.WriteLine();
        }
    }
}

O código anterior cria uma tabela que começa com “demo” e o GUID gerado é anexado ao nome da tabela.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Em seguida, adiciona uma entidade de cliente com nome e sobrenome como "Valter Lima" e, posteriormente atualiza o número de telefone desse usuário.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

Neste tutorial, você compilou um código para executar operações CRUD básicas nos dados armazenados na conta de API de Tabela.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. Também é possível executar operações avançadas como – inserir dados em lotes, consultar todos os dados em uma partição, consultar um intervalo de dados em uma partição, listar tabelas na conta cujos nomes iniciam com o prefixo especificado.You can also perform advanced operations such as – batch inserting data, query all the data within a partition, query a range of data within a partition, Lists tables in the account whose names begin with the specified prefix. Você pode baixar o formulário de exemplo completo azure-cosmos-table-dotnet-core-getting-started do repositório GitHub.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. A classe AdvancedSamples.cs tem mais operações que podem ser executadas nos dados.The AdvancedSamples.cs class has more operations that you can perform on the data.

Executar o projetoRun the project

No projeto CosmosTableSamples.From your project CosmosTableSamples. Abra a classe chamada Program.cs e adicione o código a seguir a ela para chamar BasicSamples quando o projeto for executado.Open the class named Program.cs and add the following code to it for calling BasicSamples when the project runs.

using System;

namespace CosmosTableSamples
{
    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Azure Cosmos Table Samples");
            BasicSamples basicSamples = new BasicSamples();
            basicSamples.RunSamples().Wait();
           
            Console.WriteLine();
            Console.WriteLine("Press any key to exit");
            Console.Read();
        }
    }
}

Agora, compile a solução e pressione F5 para executar o projeto.Now build the solution and press F5 to run the project. Quando o projeto for executado, a seguinte saída no prompt de comando será exibida:When the project is run, you will see the following output in the command prompt:

Saída do prompt de comando

Se você receber um erro informando que o arquivo Settings.json não pode ser encontrado ao executar o projeto, será possível resolver isso adicionando a seguinte entrada XML às configurações do projeto.If you receive an error that says Settings.json file can’t be found when running the project, you can resolve it by adding the following XML entry to the project settings. Clique com o botão direito em CosmosTableSamples, selecione Editar CosmosTableSamples.csproj e adicione o seguinte itemGroup:Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

  <ItemGroup>
    <None Update="Settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

Agora, você pode entrar no portal do Azure e verificar se os dados existem na tabela.Now you can sign into the Azure portal and verify that the data exists in the table.

Resultados no portal

Próximas etapasNext steps

Você pode avançar para o próximo tutorial e saber como migrar dados para conta de API de Tabela do Azure Cosmos DB.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.