Snelstart: Een Table API-app maken met .NET SDK en Azure Cosmos DB

VAN TOEPASSING OP: Tabel-API

In deze quickstart ziet u hoe u toegang hebt tot de Azure Cosmos DB Table API vanuit een .NET-toepassing. De Cosmos DB Table API is een schemaloos gegevensopslag waarin toepassingen gestructureerde NoSQL-gegevens kunnen opslaan in de cloud. Omdat gegevens worden opgeslagen in een schemaloos ontwerp, worden nieuwe eigenschappen (kolommen) automatisch toegevoegd aan de tabel wanneer een object met een nieuw kenmerk aan de tabel wordt toegevoegd.

.NET-toepassingen hebben toegang tot de Cosmos DB Table API met het Azure.Data.Tables NuGet-pakket. Het Azure.Data.Tables-pakket is een .NET Standard 2.0-bibliotheek die werkt met zowel .NET Framework (4.7.2 en hoger) als .NET Core (2.0 en hoger).

Vereisten

De voorbeeldtoepassing is geschreven in .NET Core 3.1,hoewel de principes van toepassing zijn op zowel .NET Framework als .NET Core-toepassingen. U kunt een Visual Studio,Visual Studio voor Macof Visual Studio code gebruiken als een IDE.

Als u geen Azure-abonnementhebt, maakt u een gratis account voordat u begint.

Voorbeeldtoepassing

De voorbeeldtoepassing voor deze zelfstudie kan worden gekloond of gedownload vanuit de https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet opslagplaats. Zowel een starters- als een voltooide app zijn opgenomen in de voorbeeldopslagplaats.

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

De voorbeeldtoepassing gebruikt weergegevens als voorbeeld om de mogelijkheden van de Tabel-API aan te tonen. Objecten die weerobservaties vertegenwoordigen, worden opgeslagen en opgehaald met de Tabel-API, inclusief het opslaan van objecten met extra eigenschappen om de schemaloze mogelijkheden van de Tabel-API aan te tonen.

Een schermafbeelding van de voltooide toepassing met gegevens die zijn opgeslagen in een Cosmos DB-tabel met de Tabel-API.

1 - Een Azure Cosmos DB-account maken

U moet eerst een API-account voor Cosmos DB Tables maken dat de tabel(en) bevat die in uw toepassing worden gebruikt. U kunt dit doen met de Azure Portal, Azure CLI of Azure PowerShell.

Meld u aan bij de Azure-portal en volg deze stappen om een Cosmos DB-account te maken.

Instructies Schermafbeelding
In de Azure-portal:
  1. Voer in de zoekbalk boven aan de Azure-portal 'kosmos db' in.
  2. Selecteer in het menu dat onder de zoekbalk wordt weergegeven, onder Serviceshet item met de naam Azure Cosmos DB.
Een schermafbeelding van het gebruik van het zoekvak in de bovenste werkbalk om De DB-accounts van Cosmos te zoeken in Azure.
Selecteer op de pagina Azure Cosmos DB de optie +Maken. Een schermafbeelding met de locatie van de knop Maken op de pagina Met DB-accounts in Azure.
Kies op de pagina Api selecteren de optie Azure Table. Een schermafbeelding met de optie Azure Table als de juiste optie om te selecteren.
Vul op de pagina Azure Cosmos DB-account maken - Azure Table het formulier als volgt in.
  1. Maak een nieuwe resourcegroep voor het opslagaccount met de naam rg-msdocs-tables-sdk-demo door de koppeling rg-msdocs-tables-sdk-demo maken onder Resourcegroep te selecteren.
  2. Geef uw opslagaccount een naam van waar XYZ drie willekeurige tekens zijn om cosmos-msdocs-tables-sdk-demo-XYZ een unieke accountnaam te maken. Azure Cosmos DB-accountnamen moeten tussen de 3 en 44 tekens lang zijn en mogen alleen kleine letters, cijfers of het afbreekstreester (-) teken bevatten.
  3. Selecteer de regio voor uw opslagaccount.
  4. Selecteer Standaardprestaties.
  5. Selecteer Inrichtende doorvoer voor dit voorbeeld onder Capaciteitsmodus.
  6. Selecteer Toepassen onder Gratis laagkorting toepassen voor dit voorbeeld.
  7. Selecteer de knop Controleren + maken onder aan het scherm en selecteer vervolgens 'Maken' in het overzichtsscherm om uw Azure Cosmos DB-account te maken. Dit proces kan enkele minuten duren.
Een schermafbeelding van het invullen van de velden op de pagina Voor het maken van DB-account van De Kosmos.

2 - Een tabel maken

Vervolgens moet u een tabel maken in uw Cosmos DB-account voor uw toepassing die u wilt gebruiken. In tegenstelling tot een traditionele database hoeft u alleen de naam van de tabel op te geven, niet de eigenschappen (kolommen) in de tabel. Wanneer gegevens in de tabel worden geladen, worden de eigenschappen (kolommen) automatisch gemaakt als dat nodig is.

Voltooi in de Azure-portalde volgende stappen om een tabel te maken in uw Db-account van De Kosmos.

Instructies Schermafbeelding
Ga in de Azure-portal naar de overzichtspagina voor het Azure Cosmos DB-account. U kunt naar de overzichtspagina voor uw Cosmos DB-account gaan door de naam (kosmos-msdocs-tables-sdk-demo-XYZ) van uw Cosmos DB-account in de bovenste zoekbalk te typen en onder de resourceskoppen te kijken. Selecteer de naam van uw Azure Cosmos DB-account om naar de overzichtspagina te gaan. Een schermafbeelding van het gebruik van het zoekvak in de bovenste werkbalk om uw Db-account voor De Kosmos te vinden.
Selecteer op de overzichtspagina +Tabel toevoegen. Het dialoogvenster Nieuwe tabel schuift vanaf de rechterkant van de pagina naar buiten. Een schermafbeelding met de locatie van de knop Tabel toevoegen.
Vul in het dialoogvenster Nieuwe tabel het formulier als volgt in.
  1. Voer de naam WeatherData in voor de tabel-id. Dit is de naam van de tabel.
  2. Selecteer Handmatig onder Tabeldoorvoer (autoschaal) voor dit voorbeeld.
  3. Gebruik de standaardwaarde van 400 onder de geschatte WAARDE/voorwaarden.
  4. Selecteer de knop OK om de tabel te maken.
Een schermafbeelding van het dialoogvenster Nieuwe tabel voor een Db-tabel van De Kosmos.

3 - Verbindingsreeks Voor Cosmos DB

Om toegang te krijgen tot uw tabel(en) in Cosmos DB, heeft uw app de tekenreeks voor de tabelverbinding nodig voor de Storage account. De verbindingsreeks kan worden opgehaald met de Azure Portal, Azure CLI of Azure PowerShell.

Instructies Schermafbeelding
Ga aan de linkerkant van de accountpagina van Azure Cosmos DB naar het menuitem Verbindingsreeks onder de Instellingen en selecteer deze. U gaat naar een pagina waar u de verbindingsreeks voor het opslagaccount kunt ophalen. Een schermafbeelding met de locatie van de koppeling tussen verbindingsreeksen op de pagina Cosmos DB.
Kopieer de waarde PRIMAIRE VERBINDINGSREEKS die u wilt gebruiken in uw toepassing. Een schermafbeelding van de verbindingsreeks die u wilt selecteren en gebruiken in uw toepassing.

De verbindingsreeks voor uw Cosmos DB-account wordt beschouwd als een app-geheim en moet net als elk ander app-geheim of wachtwoord worden beveiligd. In dit voorbeeld wordt het hulpprogramma Secret Manager gebruikt om de verbindingsreeks op te slaan tijdens de ontwikkeling en deze beschikbaar te maken voor de toepassing. Het hulpprogramma Secret Manager kan worden gebruikt vanuit een Visual Studio of de .NET CLI.

Als u het hulpprogramma Secret Manager vanuit Visual Studio wilt openen, klikt u met de rechtermuisknop op het project en selecteert u Gebruikersgeheimen beheren in het contextmenu. Hiermee wordt het bestand secrets.json voor het project geopend. Vervang de inhoud van het bestand door de JSON hieronder en vervang deze in de Verbindingsreeks voor de Db-tabel van De Kosmos.

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

4 - Azure.Data.Tables NuGet-pakket installeren

Installeer het NuGet-pakket Azure.Data.Tables om toegang te krijgen tot de Cosmos DB Table API vanuit een .NET-toepassing.

Install-Package Azure.Data.Tables

5 - De tabelclient configureren in Startup.cs

De Azure SDK communiceert met Azure met behulp van clientobjecten om verschillende bewerkingen uit te voeren tegen Azure. Het Object TableClient is het object dat wordt gebruikt om te communiceren met de Db Table API van Cosmos.

In een toepassing wordt meestal één TableClient-object per tabel gemaakt dat in de hele toepassing moet worden gebruikt. Het wordt aanbevolen om afhankelijkheidsinjectie (DI) te gebruiken en het TableClient-object te registreren als een singleton om dit te bereiken. Zie Afhankelijkheidsinjectie met de Azure SDK voor .NETvoor meer informatie over het gebruik van DI met de Azure SDK.

Bewerk in het bestand van de Startup.cs toepassing de methode ConfigureServices() om het volgende codefragment aan te passen:

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

U moet ook het volgende toevoegen met behulp van een instructie boven aan het bestand Startup.cs.

using Azure.Data.Tables;

6 - Cosmos DB-tabelbewerkingen implementeren

Alle Cosmos DB-tabelbewerkingen voor de voorbeeld-app worden geïmplementeerd in de TableService klas in de TableService U moet de en naamruimten boven aan dit bestand importeren om te kunnen werken met AzureAzure.Data.Tables objecten in het Azure.Data.Tables SDK-pakket.

using Azure;
using Azure.Data.Tables;

Voeg aan het begin van de klas een lidvariabele toe voor het TableServiceTableService en een constructor, zodat het Object TableClient in de klas kan worden geïnjecteerd.

private TableClient _tableClient;

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

Rijen uit een tabel halen

De klasse TableClient bevat een methode met de naam Query waarmee u rijen uit de tabel kunt selecteren. In dit voorbeeld worden alle rijen geselecteerd uit de tabel, omdat er geen parameters worden doorgegeven aan de methode.

Voor de methode wordt ook een algemene parameter van het type ITableEntity gebruikt die aangeeft dat de gegevens van de modelklasse worden geretourneerd als. In dit geval wordt de ingebouwde klas TableEntity gebruikt, wat betekent dat de methode een verzameling als Pageable<TableEntity> resultaat geeft.

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

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

De klasse TableEntity die in het pakket is gedefinieerd, heeft eigenschappen voor de partitiesleutel en rijsleutelwaarden in de tabel. Deze twee waarden samen voor een unieke sleutel voor de rij in de tabel. In deze voorbeeldtoepassing wordt de naam van het weerstation (plaats) opgeslagen in de partitiesleutel en wordt de datum/tijd van de waarneming opgeslagen in de rijtoets. Alle andere eigenschappen (temperatuur, vochtigheid, windsnelheid) worden opgeslagen in een woordenlijst in het TableEntity object.

Het is gebruikelijk om een TableEntity-object toe te wijsen aan een object van uw eigen definitie. De voorbeeldtoepassing definieert hiervoor een klasse WeatherDataModel in WeatherDataModel adreslijst Modellen. Deze klasse heeft eigenschappen voor de naam van het station en de waarnemingsdatum waarop de partitiesleutel en rijsleutel worden toebedeeld, zodat deze waarden meer betekenis hebben. Vervolgens wordt een woordenlijst gebruikt om alle andere eigenschappen van het object op te slaan. Dit is een veelvoorkomende patroon bij het werken met tabelopslag, omdat een rij een willekeurig aantal eigenschappen kan hebben en we willen dat onze modelobjecten ze allemaal kunnen vastleggen. Deze klas bevat ook methoden om de eigenschappen in de klas op te geven.

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

De MapTableEntityToWeatherDataModel methode wordt gebruikt om een MapTableEntityToWeatherDataModel toe te wijsen aan een WeatherDataModel object. Het object TableEntity bevat een eigenschap Sleutels om alle eigenschapsnamen in de tabel voor het object op te halen (de kolomnamen voor deze rij in de tabel). Met de methode worden de eigenschappen , en de eigenschappen rechtstreeks in kaart gebracht en wordt de eigenschap vervolgens gebruikt om de eigenschappen in het object te wijzigen en deze toe te wijden aan het object, minus de eigenschappen die al rechtstreeks zijn in MapTableEntityToWeatherDataModelPartitionKey kaart RowKeyTimestampEtagKeysTableEntityWeatherDataModel gebracht.

Bewerk de code in de MapTableEntityToWeatherDataModel methode om het volgende codeblok aan te passen.

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

Rijen filteren die zijn geretourneerd uit een tabel

Als u de rijen uit een tabel wilt filteren, kunt u een OData-stijlfilterreeks doorgeven aan de querymethode. Als u bijvoorbeeld alle weersvoorspelingen voor Chicago tussen middernacht 1 juli 2021 en middernacht 2 juli 2021 (inclusief) wilt krijgen, passeert u de volgende filterreeks.

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

U kunt alle OData-filteroperatoren weergeven op de OData-website in de sectie Filter System Query Option.

In de voorbeeldtoepassing is het object ontworpen om alle filtercriteria vast te FilterResultsInputModel leggen die door de gebruiker zijn opgegeven.

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

Wanneer dit object wordt doorgegeven aan de methode in de klas, wordt er een GetFilteredRowsTableService filterreeks gemaakt voor elke niet-null-eigenschapswaarde. Vervolgens wordt een gecombineerde filterreeks gemaakt door alle waarden samen te brengen met een 'en'-component. Deze gecombineerde filterreeks wordt doorgegeven aan de querymethode op het object TableClient en alleen rijen die overeenkomen met de filterreeks worden geretourneerd. U kunt een soortgelijke methode in uw code gebruiken om geschikte filterreeksen te maken, zoals vereist door uw toepassing.

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

Gegevens invoegen met een TableEntity-object

De eenvoudigste manier om gegevens toe te voegen aan een tabel is met behulp van een TableEntity-object. In dit voorbeeld worden gegevens van een invoermodelobject aan een TableEntity-object toegesneden. De eigenschappen op het invoerobject die de naam van het weerstation en de waarnemingsdatum/tijd vertegenwoordigen, worden respectievelijk aan de eigenschappen PartitionKey en RowKey toegesneden, die samen een unieke sleutel vormen voor de rij in de tabel. Vervolgens worden de extra eigenschappen van het invoermodelobject aan woordenlijsteigenschappen van het object TableEntity toegesneden. Ten slotte wordt de methode AddEntity op het object TableClient gebruikt om gegevens in te voegen in de tabel.

Wijzig de InsertTableEntity klas in de voorbeeldtoepassing om de volgende code te bevatten.

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

Upsert-gegevens met een TableEntity-object

Als u een rij probeert in te voegen in een tabel met een combinatie tussen partitietoetsen/rijtoetsen die al in die tabel aanwezig is, krijgt u een foutmelding. Daarom is het vaak beter om de upsertEntity te gebruiken in plaats van de methode AddEntity bij het toevoegen van rijen aan een tabel. Als de opgegeven combinatie tussen partitietoets en rijtoets al bestaat in de tabel, wordt de bestaande rij bijgewerkt met de methode UpsertEntity. Anders wordt de rij toegevoegd aan de tabel.

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

Gegevens invoegen of upsert met variabele eigenschappen

Een van de voordelen van het gebruik van de Cosmos DB Table API is dat als een object dat wordt geladen in een tabel nieuwe eigenschappen bevat, deze eigenschappen automatisch worden toegevoegd aan de tabel en de waarden die zijn opgeslagen in Cosmos DB. U hoeft DDL-instructies zoals ALTER TABLE niet uit te voeren om kolommen toe te voegen zoals in een traditionele database.

Dit model biedt uw toepassing flexibiliteit bij het omgaan met gegevensbronnen die kunnen toevoegen of wijzigen welke gegevens in de tijd moeten worden vastgelegd of wanneer verschillende invoer verschillende gegevens aan uw toepassing levert. In de voorbeeldtoepassing kunnen we een weerstation simuleren dat niet alleen de basisweergegevens maar ook enkele extra waarden verzendt. Wanneer een object met deze nieuwe eigenschappen voor het eerst in de tabel wordt opgeslagen, worden de bijbehorende eigenschappen (kolommen) automatisch aan de tabel toegevoegd.

In de voorbeeldtoepassing is de klas opgebouwd rond een interne woordenlijst ter ondersteuning van ExpandableWeatherObject alle eigenschappen van het object. Deze klasse vertegenwoordigt een normaal patroon voor wanneer een object een willekeurige set eigenschappen moet bevatten.

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

Als u een dergelijk object wilt invoegen of upsert met behulp van de Tabel-API, kunt u de eigenschappen van het uitbreekbare object in een TableEntity-object in- of bijvoegen en de methoden AddEntity of UpsertEntity gebruiken voor het Object TableClient.

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

Een entiteit bijwerken

Entiteiten kunnen worden bijgewerkt door de methode UpdateEntity op het object TableClient aan te roepen. Omdat een entiteit (rij) die is opgeslagen met de Tabel-API willekeurige eigenschappen kan bevatten, is het vaak handig om een updateobject te maken rond een dictionary-object dat lijkt op het eerder besproken ExpandableWeatherObject object. In dit geval is het enige verschil de toevoeging van een eigenschap die wordt gebruikt voor gelijktijdigheidsbeheer Etag tijdens updates.

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

In de voorbeeld-app wordt dit object doorgegeven aan de UpdateEntity methode in de TableService klas. Met deze methode wordt eerst de bestaande entiteit geladen vanuit de Tabel-API met de methode GetEntity op tableClient. Vervolgens wordt dat entiteitsobject bijgewerkt en wordt de methode UpdateEntity gebruikt om de updates op te slaan in de database. Houd er rekening mee dat met de methode UpdateEntity de huidige Etag van het object wordt gebruikt om te verzekeren dat het object niet is gewijzigd sinds het in eerste instantie is geladen. Als u de entiteit ongeacht de update wilt bijwerken, kunt u een waarde van doorgeven Etag.Any aan de UpdateEntity methode.

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

Een entiteit verwijderen

Als u een entiteit uit een tabel wilt verwijderen, belt u de methode DeleteEntity op het object TableClient met de partitietoets en rijtoets van het object.

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

7 - De code uitvoeren

Voer de voorbeeldtoepassing uit om te werken met de Cosmos DB Table API. De eerste keer dat u de toepassing uit runt, zijn er geen gegevens omdat de tabel leeg is. Gebruik een van de knoppen boven aan de toepassing om gegevens toe te voegen aan de tabel.

Een schermafbeelding van de toepassing met de locatie van de knoppen die worden gebruikt om gegevens in te voegen in De Db van Desmos met de tabel A P I.

Als u de knop Invoegen met tabeltiteit selecteert, wordt een dialoogvenster geopend waarmee u een nieuwe rij kunt invoegen of bijvoegen met een object.

Een schermafbeelding van de toepassing met het dialoogvenster dat wordt gebruikt om gegevens in te voegen met een TableEntity-object.

Als u de knop Invoegen met uitvuwbare gegevens selecteert, wordt een dialoogvenster weergegeven waarmee u een object met aangepaste eigenschappen kunt invoegen, waarmee wordt gedemonstreert hoe de Db Table API van De Kosmos automatisch eigenschappen (kolommen) toevoegt aan de tabel wanneer dat nodig is. Gebruik de knop Aangepast veld toevoegen om een of meer nieuwe eigenschappen toe te voegen en deze mogelijkheid aan te tonen.

Een schermafbeelding van de toepassing met het dialoogvenster dat wordt gebruikt om gegevens in te voegen met behulp van een object met aangepaste velden.

Gebruik de knop Voorbeeldgegevens invoegen om enkele voorbeeldgegevens in de Db-tabel van De Kosmos te laden.

Een schermafbeelding van de toepassing met de locatie van de knop Voorbeeldgegevens invoegen.

Selecteer het item Filterresultaten in het bovenste menu om naar de pagina Filterresultaten te gaan. Vul op deze pagina de filtercriteria in om aan te tonen hoe een filterclausule kan worden gemaakt en doorgegeven aan de Cosmos DB Table API.

Een schermafbeelding van de toepassing met filterresultatenpagina en een markering van het menu-item dat wordt gebruikt om naar de pagina te navigeren.

Resources ops schonen

Wanneer u klaar bent met de voorbeeldtoepassing, moet u alle Azure-bronnen met betrekking tot dit artikel verwijderen uit uw Azure-account. U kunt dit doen door de resourcegroep te verwijderen.

Een resourcegroep kan als volgt worden verwijderd via de Azure-portal.

Instructies Schermafbeelding
Als u naar de resourcegroep wilt gaan, typt u in de zoekbalk de naam van de resourcegroep. Selecteer vervolgens op het tabblad Resourcegroepen de naam van de resourcegroep. Een schermafbeelding van het zoeken naar een resourcegroep.
Selecteer Resourcegroep verwijderen op de werkbalk boven aan de pagina resourcegroep. Een schermafbeelding met de locatie van de knop Resourcegroep verwijderen.
Rechts van het scherm verschijnt een dialoogvenster waarin u wordt gevraagd of u de resourcegroep wilt verwijderen.
  1. Typ de volledige naam van de resourcegroep in het tekstvak om te bevestigen dat de resource is verwijderd.
  2. Selecteer de knop Verwijderen onder aan de pagina.
Een schermafbeelding met het bevestigingsdialoogvenster voor het verwijderen van een resourcegroep.

Volgende stappen

In deze quickstart hebt u geleerd hoe u een Azure Cosmos DB-account maakt, een tabel maakt met de Gegevensverkenner en een app kunt uitvoeren. U kunt nu query's uitvoeren op uw gegevens met behulp van de Tabel-API.