Quickstart: Construa uma app API de tabela com .NET SDK e Azure Cosmos DB

APLICA-SE A: Tabela API

Este quickstart mostra como aceder à API de tabela DB Azure Cosmos a partir de uma aplicação .NET. A Cosmos DB Table API é uma loja de dados sem esquemas que permite que as aplicações armazenem dados noSQL estruturados na nuvem. Como os dados são armazenados num design sem esquemas, novas propriedades (colunas) são automaticamente adicionadas à tabela quando um objeto com um novo atributo é adicionado à tabela.

As aplicações .NET podem aceder à API da tabela Cosmos DB utilizando o pacote Azure.Data.Tables NuGet. O pacote Azure.Data.Tables é uma biblioteca .NET Standard 2.0 que funciona com aplicações .NET Framework (4.7.2 e posterior) e .NET Core (2.0 e posterior).

Pré-requisitos

O pedido de amostra é escrito em .NET Core 3.1, embora os princípios se apliquem tanto às aplicações .NET Framework como ao .NET Core. Pode utilizar o Visual Studio, Visual Studio para Macou Visual Studio Código como IDE.

Se não tiver uma subscrição do Azure,crie uma conta gratuita antes de começar.

Aplicação de exemplo

O pedido de amostra para este tutorial pode ser clonado ou descarregado do repositório https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet . Tanto uma aplicação inicial como concluída estão incluídas no repositório de amostras.

git clone https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet

A aplicação da amostra utiliza dados meteorológicos como exemplo para demonstrar as capacidades da Tabela API. Os objetos que representam observações meteorológicas são armazenados e recuperados utilizando a Tabela API, incluindo o armazenamento de objetos com propriedades adicionais para demonstrar as capacidades de esquema da API de tabela.

Uma imagem da aplicação acabada mostrando dados armazenados numa tabela DeSP cosmos utilizando a Tabela API.

1 - Criar uma conta DB Azure Cosmos

Primeiro precisa de criar uma conta API de Tabelas De Cosmos que contenha a tabela(s) utilizada na sua aplicação. Isto pode ser feito usando o portal Azure, Azure CLI, ou Azure PowerShell.

Faça login no portal Azure e siga estes passos para criar uma conta Cosmos DB.

Instruções Captura de ecrã
No portal do Azure:
  1. Na barra de pesquisa no topo do portal Azure, insira "cosmos db".
  2. No menu que aparece abaixo da barra de pesquisa, em Serviços, selecione o item rotulado Azure Cosmos DB.
Uma imagem mostrando como usar a caixa de pesquisa na barra de ferramentas superior para encontrar contas de Cosmos DB em Azure.
Na página DB do Azure Cosmos selecione +Criar. Uma imagem mostrando a localização do botão Create na página de contas do Cosmos DB em Azure.
Na página de opção API Select escolha a opção Azure Table. Uma imagem mostrando a opção Azure Table como a opção correta para selecionar.
Na conta DB Create Azure Cosmos - Azure Table, preencha o formulário da seguinte forma.
  1. Criar um novo grupo de recursos para a conta de armazenamento nomeado rg-msdocs-tables-sdk-demo selecionando a nova ligação Create no grupo De recursos.
  2. Dê à sua conta de armazenamento um nome de cosmos-msdocs-tables-sdk-demo-XYZ onde XYZ são três caracteres aleatórios para criar um nome de conta único. Os nomes da conta Azure Cosmos DB devem ter entre 3 e 44 caracteres de comprimento e podem conter apenas letras minúsculas, números ou o caracteres hífen (-).
  3. Selecione a região para a sua conta de armazenamento.
  4. Selecione desempenho standard.
  5. Selecione Produção provisionada para este exemplo no modo capacidade.
  6. Selecione Aplicar em Desconto de Nível Gratuito para este exemplo.
  7. Selecione o botão Review + create na parte inferior do ecrã e, em seguida, selecione "Criar" no ecrã resumida para criar a sua conta DB Azure Cosmos. Este processo pode demorar vários minutos.
Uma imagem mostrando como preencher os campos na página de criação da Conta Cosmos DB.

2 - Criar uma tabela

Em seguida, precisa de criar uma tabela dentro da sua conta Cosmos DB para a sua aplicação usar. Ao contrário de uma base de dados tradicional, basta especificar o nome da tabela, não as propriedades (colunas) na tabela. À medida que os dados são carregados na sua tabela, as propriedades (colunas) serão criadas automaticamente conforme necessário.

No portal Azure,complete os seguintes passos para criar uma tabela dentro da sua conta Cosmos DB.

Instruções Captura de ecrã
No portal Azure, navegue para a página geral para a conta DB do Azure Cosmos. Você pode navegar para a página geral para a sua conta Cosmos DB digitando o nome (cosmos-msdocs-tables-sdk-demo-XYZ) da sua conta Cosmos DB na barra de pesquisa superior e olhando para baixo do título de recursos.Selecione o nome da sua conta DB Azure Cosmos para ir à página geral. Uma imagem mostrando como usar a caixa de pesquisa na barra de ferramentas superior para encontrar a sua conta Cosmos DB.
Na página geral, selecione +Adicionar Tabela. O diálogo new table irá deslizar para fora do lado direito da página. Uma imagem mostrando a localização do botão Add Table.
No diálogo New Table, preencha o formulário da seguinte forma.
  1. Introduza o nome WeatherData para o ID da tabela. Este é o nome da mesa.
  2. Selecione Manual sob a produção da tabela (autoescala) para este exemplo.
  3. Utilize o valor predefinido de 400 segundo os seus RU/s estimados.
  4. Selecione o botão OK para criar a tabela.
Uma imagem mostrando como a caixa de diálogo new table para uma tabela Cosmos DB.

3 - Obter cadeia de ligação Cosmos DB

Para aceder à sua mesa(s) em Cosmos DB, a sua aplicação necessitará da cadeia de ligação de mesa para a conta cosmosDB Armazenamento. A cadeia de ligação pode ser recuperada utilizando o portal Azure CLI ou Azure PowerShell.

Instruções Captura de ecrã
No lado esquerdo da página da conta DB Azure Cosmos, localize o item do menu chamado Connection String sob o cabeçalho Definições e selecione-o. Será levado para uma página onde pode recuperar o fio de ligação para a conta de armazenamento. Uma imagem mostrando a localização da ligação das cordas de ligação na página cosmos DB.
Copie o valor de STRING DE LIGAÇÃO PRIMÁRIA para utilizar na sua aplicação. Uma imagem mostrando qual cadeia de ligação para selecionar e usar na sua aplicação.

A cadeia de ligação para a sua conta Cosmos DB é considerada um segredo de aplicação e deve ser protegida como qualquer outro segredo de aplicação ou senha. Este exemplo utiliza a ferramenta Secret Manager para armazenar a cadeia de ligação durante o desenvolvimento e disponibilizá-la à aplicação. A ferramenta Secret Manager pode ser acedida a partir de Visual Studio ou do .NET CLI.

Para abrir a ferramenta Secret Manager a partir de Visual Studio, clique com o botão direito no projeto e selecione Gerir segredos de utilizador a partir do menu de contexto. Isto abrirá o ficheiro secrets.json para o projeto. Substitua o conteúdo do ficheiro pelo JSON abaixo, substituindo na sua cadeia de ligação à mesa Cosmos DB.

{
  "ConnectionStrings": {
    "CosmosTableApi": "<cosmos db table connection string>"
  }  
}

4 - Instalar pacote Azure.Data.Tables NuGet

Para aceder à API da tabela Cosmos DB a partir de uma aplicação .NET, instale o pacote Azure.Data.Tables NuGet.

Install-Package Azure.Data.Tables

5 - Configurar o cliente da Tabela no Arranque.cs

O Azure SDK comunica com a Azure usando objetos de cliente para executar diferentes operações contra a Azure. O objeto TableClient é o objeto utilizado para comunicar com a Tabela Cosmos DB API.

Uma aplicação irá normalmente criar um único objeto TableClient por tabela a ser usado ao longo da aplicação. Recomenda-se a utilização da injeção de dependência (DI) e registar o objeto TableClient como um singleton para o conseguir. Para obter mais informações sobre a utilização de DI com o Azure SDK, consulte a injeção de dependência com o Azure SDK para .NET.

No Startup.cs ficheiro da aplicação, edite o método ConfigureServices() para corresponder ao seguinte corte de código:

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages()
        .AddMvcOptions(options =>
        {
            options.Filters.Add(new ValidationFilter());
        });
    
    var connectionString = Configuration.GetConnectionString("CosmosTableApi");
    services.AddSingleton<TableClient>(new TableClient(connectionString, "WeatherData"));
    
    services.AddSingleton<TablesService>();
}

Também terá de adicionar a seguinte declaração utilizando o ficheiro .cs Arranque.

using Azure.Data.Tables;

6 - Implementar operações de tabela Cosmos DB

Todas as operações de mesa da Cosmos DB para a aplicação da amostra são implementadas na TableService classe localizada no diretório de serviços. Você precisará importar os Azure espaços e os espaços de nome no topo deste arquivo para trabalhar com Azure.Data.Tables objetos no pacote Azure.Data.Tables SDK.

using Azure;
using Azure.Data.Tables;

No início da TableService aula, adicione uma variável de membro para o objeto TableClient e um construtor para permitir que o objeto TableClient seja injetado na classe.

private TableClient _tableClient;

public TablesService(TableClient tableClient)
{
    _tableClient = tableClient;
}

Obter filas de uma mesa

A classe TableClient contém um método chamado Consulta que lhe permite selecionar linhas a partir da tabela. Neste exemplo, uma vez que não estão a ser passados parâmetros para o método, todas as linhas serão selecionadas a partir da tabela.

O método também requer um parâmetro genérico do tipo ITableEntity que especifica que os dados da classe modelo serão devolvidos conforme. Neste caso, é utilizada a Classe Incorporada TableEntity, o que significa que o Query método devolverá uma Pageable<TableEntity> coleção como resultado.

public IEnumerable<WeatherDataModel> GetAllRows()
{
    Pageable<TableEntity> entities = _tableClient.Query<TableEntity>();

    return entities.Select(e => MapTableEntityToWeatherDataModel(e));
}

A classe TableEntity definida no Azure.Data.Tables pacote tem propriedades para os valores-chave da chave de partição e linha na tabela. Juntos, estes dois valores para uma chave única para a linha na mesa. Nesta aplicação de exemplo, o nome da estação meteorológica (cidade) é armazenado na chave de partição e a data/hora da observação é armazenada na tecla de linha. Todas as outras propriedades (temperatura, humidade, velocidade do vento) são armazenadas num dicionário no TableEntity objeto.

É prática comum mapear um objeto da TableEntity para um objeto da sua própria definição. A aplicação da amostra define uma classe WeatherDataModel no diretório de modelos para o efeito. Esta classe tem propriedades para o nome da estação e data de observação que a chave de partição e chave de linha irá mapear, fornecendo nomes de propriedade mais significativos para estes valores. Em seguida, usa um dicionário para armazenar todas as outras propriedades no objeto. Este é um padrão comum quando se trabalha com o armazenamento de mesa uma vez que uma linha pode ter várias propriedades arbitrárias e queremos que os nossos objetos de modelo sejam capazes de capturar todos eles. Esta classe também contém métodos para listar as propriedades da classe.

public class WeatherDataModel 
{
    // Captures all of the weather data properties -- temp, humidity, wind speed, etc
    private Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }

    public string ObservationDate { get; set; }

    public DateTimeOffset? Timestamp { get; set; }

    public string Etag { get; set; }

    public object this[string name] 
    { 
        get => ( ContainsProperty(name)) ? _properties[name] : null; 
        set => _properties[name] = value; 
    }
    
    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);       
}

O MapTableEntityToWeatherDataModel método é usado para mapear um objeto da Entidade de Tabela para um WeatherDataModel objeto. O objeto TableEntity contém uma propriedade Keys para obter todos os nomes de propriedade contidos na tabela para o objeto (efetivamente os nomes da coluna para esta linha na tabela). O MapTableEntityToWeatherDataModel método mapeia diretamente o PartitionKey , e propriedades RowKey Timestamp Etag e, em seguida, usa a Keys propriedade para iterar sobre as outras propriedades no TableEntity objeto e mapear as para o WeatherDataModel objeto, menos as propriedades que já foram diretamente mapeadas.

Edite o código no MapTableEntityToWeatherDataModel método para corresponder ao seguinte bloco de código.

public WeatherDataModel MapTableEntityToWeatherDataModel(TableEntity entity)
{
    WeatherDataModel observation = new WeatherDataModel();
    observation.StationName = entity.PartitionKey;
    observation.ObservationDate = entity.RowKey;
    observation.Timestamp = entity.Timestamp;
    observation.Etag = entity.ETag.ToString();

    var measurements = entity.Keys.Where(key => !EXCLUDE_TABLE_ENTITY_KEYS.Contains(key));
    foreach (var key in measurements)
    {
        observation[key] = entity[key];
    }
    return observation;            
}

Linhas de filtro devolvidas de uma mesa

Para filtrar as linhas devolvidas de uma mesa, pode passar uma corda de filtro estilo OData para o método Dery. Por exemplo, se quisesse obter todas as leituras meteorológicas para Chicago entre a meia-noite de 1 de julho de 2021 e a meia-noite de 2 de julho de 2021 (inclusive) passaria na seguinte corda de filtro.

PartitionKey eq 'Chicago' and RowKey ge '2021-07-01 12:00 AM' and RowKey le '2021-07-02 12:00 AM'

Pode ver todos os operadores de filtros OData no site OData na secção Filter System Query Option.

Na aplicação exemplo, o FilterResultsInputModel objeto foi concebido para capturar quaisquer critérios de filtro fornecidos pelo utilizador.

public class FilterResultsInputModel : IValidatableObject
{
    public string PartitionKey { get; set; }
    public string RowKeyDateStart { get; set; }
    public string RowKeyTimeStart { get; set; }
    public string RowKeyDateEnd { get; set; }
    public string RowKeyTimeEnd { get; set; }
    [Range(-100, +200)]
    public double? MinTemperature { get; set; }
    [Range(-100,200)]
    public double? MaxTemperature { get; set; }
    [Range(0, 300)]
    public double? MinPrecipitation { get; set; }
    [Range(0,300)]
    public double? MaxPrecipitation { get; set; }
}

Quando este objeto é passado para o GetFilteredRows método da TableService classe, cria uma corda de filtro para cada valor de propriedade não nulo. Em seguida, cria uma cadeia de filtro combinada juntando todos os valores juntamente com uma cláusula "e". Esta cadeia de filtro combinada é passada para o método de consulta no objeto TableClient e apenas serão devolvidas linhas correspondentes à cadeia do filtro. Pode utilizar um método semelhante no seu código para construir cordas de filtro adequadas, conforme exigido pela sua aplicação.

public IEnumerable<WeatherDataModel> GetFilteredRows(FilterResultsInputModel inputModel)
{
    List<string> filters = new List<string>();

    if (!String.IsNullOrEmpty(inputModel.PartitionKey))
        filters.Add($"PartitionKey eq '{inputModel.PartitionKey}'");
    if (!String.IsNullOrEmpty(inputModel.RowKeyDateStart) && !String.IsNullOrEmpty(inputModel.RowKeyTimeStart))
        filters.Add($"RowKey ge '{inputModel.RowKeyDateStart} {inputModel.RowKeyTimeStart}'");
    if (!String.IsNullOrEmpty(inputModel.RowKeyDateEnd) && !String.IsNullOrEmpty(inputModel.RowKeyTimeEnd))
        filters.Add($"RowKey le '{inputModel.RowKeyDateEnd} {inputModel.RowKeyTimeEnd}'");
    if (inputModel.MinTemperature.HasValue)
        filters.Add($"Temperature ge {inputModel.MinTemperature.Value}");
    if (inputModel.MaxTemperature.HasValue)
        filters.Add($"Temperature le {inputModel.MaxTemperature.Value}");
    if (inputModel.MinPrecipitation.HasValue)
        filters.Add($"Precipitation ge {inputModel.MinTemperature.Value}");
    if (inputModel.MaxPrecipitation.HasValue)
        filters.Add($"Precipitation le {inputModel.MaxTemperature.Value}");

    string filter = String.Join(" and ", filters);
    Pageable<TableEntity> entities = _tableClient.Query<TableEntity>(filter);

    return entities.Select(e => MapTableEntityToWeatherDataModel(e));
}

Insira dados usando um objeto Da Entidade de Tabela

A forma mais simples de adicionar dados a uma tabela é utilizando um objeto Da Entidade de Tabela. Neste exemplo, os dados são mapeados de um objeto de modelo de entrada para um objeto da TableEntity. As propriedades no objeto de entrada que representam o nome da estação meteorológica e a data/hora de observação são mapeadas para as propriedades PartitionKey e RowKey, respectivamente, que juntos formam uma chave única para a linha na tabela. Em seguida, as propriedades adicionais no objeto do modelo de entrada são mapeadas para propriedades de dicionário no objeto Da Entidade de Tabela. Finalmente, o método AddEntity no objeto TableClient é utilizado para inserir dados na tabela.

Modifique a InsertTableEntity classe na aplicação de exemplo para conter o seguinte código.

public void InsertTableEntity(WeatherInputModel model)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = model.StationName;
    entity.RowKey = $"{model.ObservationDate} {model.ObservationTime}";

    // The other values are added like a items to a dictionary
    entity["Temperature"] = model.Temperature;
    entity["Humidity"] = model.Humidity;
    entity["Barometer"] = model.Barometer;
    entity["WindDirection"] = model.WindDirection;
    entity["WindSpeed"] = model.WindSpeed;
    entity["Precipitation"] = model.Precipitation;

    _tableClient.AddEntity(entity);
}

Aumentar os dados utilizando um objeto da Entidade de Tabela

Se tentar inserir uma linha numa tabela com uma combinação chave de chave/linha de partição que já existe nessa tabela, receberá um erro. Por esta razão, é muitas vezes preferível utilizar a UpsertEntity em vez do método AddEntity ao adicionar linhas a uma tabela. Se a combinação de chave de partição/linha já existir na tabela, o método UpsertEntity atualizará a linha existente. Caso contrário, a linha será adicionada à mesa.

public void UpsertTableEntity(WeatherInputModel model)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = model.StationName;
    entity.RowKey = $"{model.ObservationDate} {model.ObservationTime}";

    // The other values are added like a items to a dictionary
    entity["Temperature"] = model.Temperature;
    entity["Humidity"] = model.Humidity;
    entity["Barometer"] = model.Barometer;
    entity["WindDirection"] = model.WindDirection;
    entity["WindSpeed"] = model.WindSpeed;
    entity["Precipitation"] = model.Precipitation;

    _tableClient.UpsertEntity(entity);
}

Insira ou insira dados com propriedades variáveis

Uma das vantagens de usar a Tabela Cosmos DB API é que se um objeto sendo carregado para uma mesa contém quaisquer novas propriedades, então essas propriedades são automaticamente adicionadas à tabela e os valores armazenados em Cosmos DB. Não há necessidade de executar declarações DDL como ALTER TABLE para adicionar colunas como numa base de dados tradicional.

Este modelo dá flexibilidade à sua aplicação ao lidar com fontes de dados que podem adicionar ou modificar os dados necessários para serem capturados ao longo do tempo ou quando diferentes entradas fornecem dados diferentes para a sua aplicação. Na aplicação da amostra, podemos simular uma estação meteorológica que envia não só os dados meteorológicos base, mas também alguns valores adicionais. Quando um objeto com estas novas propriedades for armazenado na tabela pela primeira vez, as propriedades correspondentes (colunas) serão automaticamente adicionadas à tabela.

Na aplicação da amostra, a ExpandableWeatherObject classe é construída em torno de um dicionário interno para suportar qualquer conjunto de propriedades no objeto. Esta classe representa um padrão típico para quando um objeto precisa conter um conjunto arbitrário de propriedades.

public class ExpandableWeatherObject
{
    public Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }

    public string ObservationDate { get; set; }

    public object this[string name]
    {
        get => (ContainsProperty(name)) ? _properties[name] : null;
        set => _properties[name] = value;
    }

    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);
}

Para inserir ou reforçar tal objeto utilizando a Tabela API, mapear as propriedades do objeto expansível num objeto da TableEntity e utilizar os métodos AddEntity ou UpsertEntity no objeto TableClient, conforme apropriado.

public void InsertExpandableData(ExpandableWeatherObject weatherObject)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = weatherObject.StationName;
    entity.RowKey = weatherObject.ObservationDate;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }
    _tableClient.AddEntity(entity);
}

        
public void UpsertExpandableData(ExpandableWeatherObject weatherObject)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = weatherObject.StationName;
    entity.RowKey = weatherObject.ObservationDate;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }
    _tableClient.UpsertEntity(entity);
}

Atualizar uma entidade

As entidades podem ser atualizadas através da chamada do método 'UpdateEntity' no objeto TableClient. Uma vez que uma entidade (linha) armazenada utilizando a API de tabela pode conter qualquer conjunto arbitrário de propriedades, é frequentemente útil criar um objeto de atualização baseado em torno de um objeto dicionário semelhante ao ExpandableWeatherObject discutido anteriormente. Neste caso, a única diferença é a adição de um Etag imóvel que é utilizado para o controlo da conusciência durante as atualizações.

public class UpdateWeatherObject
{
    public Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }
    public string ObservationDate { get; set; }
    public string Etag { get; set; }

    public object this[string name]
    {
        get => (ContainsProperty(name)) ? _properties[name] : null;
        set => _properties[name] = value;
    }

    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);
}

Na aplicação da amostra, este objeto é passado para o UpdateEntity método na TableService classe. Este método carrega primeiro a entidade existente a partir da API tabela utilizando o método GetEntity no TableClient. Em seguida, atualiza essa entidade e utiliza o UpdateEntity método para guardar as atualizações para a base de dados. Note como o método 'UpdateEntity' leva o Etag atual do objeto para garantir que o objeto não foi alterado desde que foi inicialmente carregado. Se quiser atualizar a entidade independentemente, poderá passar um valor Etag.Any ao UpdateEntity método.

public void UpdateEntity(UpdateWeatherObject weatherObject)
{
    string partitionKey = weatherObject.StationName;
    string rowKey = weatherObject.ObservationDate;

    // Use the partition key and row key to get the entity
    TableEntity entity = _tableClient.GetEntity<TableEntity>(partitionKey, rowKey).Value;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }

    _tableClient.UpdateEntity(entity, new ETag(weatherObject.Etag));
}

Remover uma entidade

Para remover uma entidade de uma tabela, ligue para o método DeleteEntity no objeto TableClient com a chave de partição e a chave de linha do objeto.

public void RemoveEntity(string partitionKey, string rowKey)
{
    _tableClient.DeleteEntity(partitionKey, rowKey);           
}

7 - Executar o código

Executar a aplicação de amostra para interagir com a Tabela Cosmos DB API. A primeira vez que executar a aplicação, não haverá dados porque a tabela está vazia. Utilize qualquer um dos botões na parte superior da aplicação para adicionar dados à tabela.

Uma imagem da aplicação mostrando a localização dos botões utilizados para inserir dados na Cosmos DB utilizando a tabela A P I.

Selecionar o botão Inserir utilizando o botão 'Entidade de Tabela' abre um diálogo que lhe permite inserir ou reforçar uma nova linha utilizando um TableEntity objeto.

Uma imagem da aplicação mostrando a caixa de diálogo utilizada para inserir dados utilizando um objeto Da Entidade de Tabela.

A seleção do Inserção utilizando o botão De dados expansíveis traz-lhe um diálogo que lhe permite inserir um objeto com propriedades personalizadas, demonstrando como a API da Tabela Cosmos DB adiciona automaticamente propriedades (colunas) à tabela quando necessário. Utilize o botão Adicionar Campo Personalizado para adicionar uma ou mais novas propriedades e demonstrar esta capacidade.

Uma imagem da aplicação mostrando a caixa de diálogo utilizada para inserir dados usando um objeto com campos personalizados.

Utilize o botão 'Inserir dados de amostra' para carregar alguns dados da amostra na sua tabela DeSMesso cosmos.

Uma imagem da aplicação que mostra a localização do botão de inserção de dados da amostra.

Selecione o item Resultados do Filtro no menu superior a ser levado para a página Resultados do Filtro. Nesta página, preencha os critérios do filtro para demonstrar como uma cláusula de filtro pode ser construída e passada para a API da Tabela DB cosmos.

Uma imagem da aplicação mostrando a página de resultados do filtro e realçando o item do menu utilizado para navegar para a página.

Limpar os recursos

Quando terminar o pedido de amostra, deve remover todos os recursos Azure relacionados com este artigo da sua conta Azure. Pode fazê-lo eliminando o grupo de recursos.

Um grupo de recursos pode ser eliminado usando o portal Azure fazendo o seguinte.

Instruções Captura de ecrã
Para ir ao grupo de recursos, na barra de pesquisa, digite o nome do grupo de recursos. Em seguida, no separador Grupos de Recursos, selecione o nome do grupo de recursos. Uma imagem mostrando como procurar um grupo de recursos.
Selecione Eliminar o grupo de recursos da barra de ferramentas no topo da página do grupo de recursos. Uma imagem mostrando a localização do botão de grupo de recursos Delete.
Um diálogo sairá da direita do ecrã pedindo-lhe que confirme a eliminação do grupo de recursos.
  1. Digite o nome completo do grupo de recursos na caixa de texto para confirmar a eliminação conforme instruído.
  2. Selecione o botão Eliminar na parte inferior da página.
Uma imagem mostrando o diálogo de confirmação para eliminar um grupo de recursos.

Passos seguintes

Neste guia de introdução, aprendeu a criar uma conta do Azure Cosmos DB, a criar uma tabela com o Data Explorer e a executar uma aplicação. Agora, pode consultar os dados com a API de Tabela.