Quickstart: Een Table-API-app bouwen met .NET SDK en Azure Cosmos DB

VAN TOEPASSING OP: Table-API

In deze quickstart ziet u hoe u toegang krijgt tot 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 wordt toegevoegd aan de tabel.

.NET-toepassingen hebben toegang tot Cosmos DB Table-API met het Azure.Data.Tables NuGet-pakket. Het pakket Azure.Data.Tables is een .NET Standard 2.0-bibliotheek die werkt met toepassingen 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 Visual Studio , Visual Studio voor Macof Visual Studio Code gebruiken als een IDE.

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

Voorbeeldtoepassing

De voorbeeldtoepassing voor deze zelfstudie kan worden gekloond of gedownload uit de opslagplaats https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet . Zowel een starter 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 weersgegevens als voorbeeld om de mogelijkheden van de Table-API. Objecten die weerwaarnemingen vertegenwoordigen, worden opgeslagen en opgehaald met behulp van de Table-API, inclusief het opslaan van objecten met aanvullende eigenschappen om de schemaloze mogelijkheden van de Table-API.

Een schermopname van de voltooide toepassing met gegevens die zijn opgeslagen in Cosmos DB tabel met behulp van de Table-API.

1 - Een Azure Cosmos DB maken

U moet eerst een Cosmos DB Tables-API-account maken dat de tabellen bevat die in uw toepassing worden gebruikt. U kunt dit doen met behulp van Azure Portal, Azure CLI of Azure PowerShell.

Meld u aan bij Azure Portal en volg deze stappen om een Cosmos DB maken.

Instructies Schermopname
In Azure Portal:
  1. Voer in de zoekbalk boven aan de Azure Portal 'cosmos db' in.
  2. Selecteer in het menu onder de zoekbalk, onder Services, het item met het label Azure Cosmos DB.
Een schermopname die laat zien hoe u het zoekvak in de bovenste werkbalk gebruikt om uw Cosmos DB te zoeken in Azure.
Selecteer op Azure Cosmos DB pagina +Maken. Een schermopname van de locatie van de knop Maken op de pagina Cosmos DB accounts in Azure.
Kies op de pagina API-optie selecteren de optie Azure Table. Een schermopname met de optie Azure Table als de juiste optie om te selecteren.
Vul op de Azure Cosmos DB Account maken - Azure Table het formulier als volgt in.
  1. Maak een nieuwe resourcegroep voor het opslagaccount met de naam door de koppeling rg-msdocs-tables-sdk-demo Nieuwe maken te selecteren onder Resourcegroep.
  2. Geef uw opslagaccount een naam waarin XYZ drie willekeurige tekens bevat cosmos-msdocs-tables-sdk-demo-XYZ om 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 koppelteken (-) bevatten.
  3. Selecteer de regio voor uw opslagaccount.
  4. Selecteer Standaardprestaties.
  5. Selecteer Inrichtende doorvoer voor dit voorbeeld onder Capaciteitsmodus.
  6. Selecteer Toepassen onder Korting voor gratis laag toepassen voor dit voorbeeld.
  7. Selecteer de knop Beoordelen en maken onderaan het scherm en selecteer vervolgens Maken op het overzichtsscherm om uw Azure Cosmos DB maken. Dit proces kan enkele minuten duren.
Een schermopname die laat zien hoe u de velden invult op Cosmos DB pagina voor het maken van een account.

2 - Een tabel maken

Vervolgens moet u een tabel maken in uw Cosmos DB account voor uw toepassing om te 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 uw tabel worden geladen, worden de eigenschappen (kolommen) automatisch gemaakt als dat nodig is.

Voltooi in Azure Portalde volgende stappen om een tabel te maken binnen uw Cosmos DB account.

Instructies Schermopname
Ga in Azure Portal naar de overzichtspagina voor het Azure Cosmos DB account. U kunt naar de overzichtspagina voor uw Cosmos DB-account navigeren door in de bovenste zoekbalk de naam (cosmos-msdocs-tables-sdk-demo-XYZ) van uw Cosmos DB-account te typen en onder de kop resources te kijken.Selecteer de naam van uw Azure Cosmos DB account om naar de overzichtspagina te gaan. Een schermopname die laat zien hoe u het zoekvak in de bovenste werkbalk gebruikt om uw Cosmos DB vinden.
Selecteer op de overzichtspagina +Tabel toevoegen. Het dialoogvenster Nieuwe tabel schuift vanaf de rechterkant van de pagina naar buiten. Een schermopname van 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 (automatisch schalen) voor dit voorbeeld.
  3. Gebruik de standaardwaarde 400 onder uw geschatte RU/s.
  4. Selecteer de knop OK om de tabel te maken.
Een schermopname van het dialoogvenster Nieuwe tabel voor een Cosmos DB tabel.

3 - Cosmos DB connection string

Voor toegang tot uw tabel(en) in Cosmos DB, heeft uw app de connection string nodig voor het CosmosDB-Storage account. De connection string kunnen worden opgehaald met behulp van Azure Portal, Azure CLI of Azure PowerShell.

Instructies Schermopname
Ga aan de linkerkant van Azure Cosmos DB accountpagina naar het menu-item met de naam Verbindingsreeks onder Instellingen koptekst en selecteer deze. U gaat naar een pagina waar u de gegevens voor connection string opslagaccount kunt ophalen. Een schermopname met de locatie van de koppeling verbindingsreeksen op Cosmos DB pagina.
Kopieer de waarde van PRIMARY CONNECTION STRING voor gebruik in uw toepassing. Een schermopname van de connection string u in uw toepassing kunt selecteren en gebruiken.

De connection string 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 connection string tijdens de ontwikkeling op te slaan en beschikbaar te maken voor de toepassing. Het hulpprogramma Secret Manager is toegankelijk via Visual Studio of de .NET CLI.

Als u het hulpprogramma Secret Manager wilt openen vanuit Visual Studio, klikt u met de rechtermuisknop op het project en selecteert u Gebruikersgeheimen beheren in het contextmenu. Hiermee opent u het bestand secrets.json voor het project. Vervang de inhoud van het bestand door de onderstaande JSON, die u vervangt door Cosmos DB tabel connection string.

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

4 - NuGet-pakket Azure.Data.Tables installeren

Als u toegang wilt Cosmos DB Table-API een .NET-toepassing, installeert u het Azure.Data.Tables NuGet-pakket.

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 op Azure uit te voeren. Het TableClient-object is het object dat wordt gebruikt om te communiceren met Cosmos DB Table-API.

Een toepassing maakt doorgaans één TableClient-object per tabel dat in de hele toepassing moet worden gebruikt. Het is raadzaam om afhankelijkheidsinjectie (DI) te gebruiken en het TableClient-object te registreren als singleton om dit te bereiken. Zie Dependency injection with the Azure SDK for .NET(Afhankelijkheidsinjectie met de Azure SDK voor .NET) voor meer informatie over het gebruik van afhankelijkheidsinjectie met de Azure SDK.

Bewerk in het bestand van de toepassing de methode ConfigureServices() zo dat Startup.cs deze overeen komt met het volgende codefragment:

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 de volgende using-instructie toevoegen boven aan het bestand Startup.cs.

using Azure.Data.Tables;

6 - Tabelbewerkingen Cosmos DB implementeren

Alle Cosmos DB tabelbewerkingen voor de voorbeeld-app worden geïmplementeerd in de TableService klasse die zich in de map Services bevindt. U moet de naamruimten en bovenaan dit bestand importeren om te kunnen werken met Azure Azure.Data.Tables objecten in het Azure.Data.Tables SDK-pakket.

using Azure;
using Azure.Data.Tables;

Voeg aan het begin van de klasse een lidvariabele toe voor het TableService TableClient-object en een constructor om het TableClient-object in de klasse toe te staan.

private TableClient _tableClient;

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

Rijen uit een tabel op halen

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

De methode gebruikt ook een algemene parameter van het type ITableEntity die aangeeft dat de modelklassegegevens als worden geretourneerd. In dit geval wordt de ingebouwde klasse TableEntity gebruikt, wat betekent dat de methode een verzameling retournt Query Pageable<TableEntity> als resultaten.

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

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

De tableEntity-klasse die in het pakket is Azure.Data.Tables gedefinieerd, heeft eigenschappen voor de partitiesleutel en rijsleutelwaarden in de tabel. Samen zijn deze twee waarden 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 observatie opgeslagen in de rijsleutel. 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 een klasse WeatherDataModel in de map Modellen voor dit doel. Deze klasse heeft eigenschappen voor de stationnaam en observatiedatum die de partitiesleutel en de rijsleutel aan worden toe te geven, waardoor meer betekenisvolle eigenschapsnamen voor deze waarden worden gegeven. Vervolgens wordt een woordenlijst gebruikt om alle andere eigenschappen van het object op te slaan. Dit is een veelvoorkomende patroon bij het werken met Table Storage, omdat een rij een willekeurig aantal eigenschappen kan hebben en we willen dat onze modelobjecten al deze eigenschappen kunnen vastleggen. Deze klasse bevat ook methoden om de eigenschappen van de klasse weer 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 TableEntity-object toe te wijsen aan een WeatherDataModel -object. Het object TableEntity bevat de eigenschap Keys om alle eigenschapsnamen op te halen die zijn opgenomen in de tabel voor het object (de kolomnamen voor deze rij in de tabel). Met de methode worden de eigenschappen , , en rechtstreeks aan elkaar toegesneden en wordt vervolgens de eigenschap gebruikt om de andere eigenschappen in het object te itereren en deze toe te wijs aan het -object, minus de eigenschappen die al rechtstreeks zijn MapTableEntityToWeatherDataModel PartitionKey RowKey Timestamp Etag Keys TableEntity WeatherDataModel toegesneden.

Bewerk de code in de MapTableEntityToWeatherDataModel methode zo dat deze overeenkomen met het volgende codeblok.

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 wilt filteren die uit een tabel worden geretourneerd, kunt u een OData-filterreeks doorgeven aan de Query-methode. Als u bijvoorbeeld alle weersmetingen voor Chicago wilt op halen tussen 1 juli 2021 middernacht en 2 juli 2021 (inclusief), geeft u de volgende filterreeks door.

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-filteroperators weergeven op de OData-website in de sectie Filter System Query Option.

In de voorbeeldtoepassing is het FilterResultsInputModel object ontworpen om filtercriteria van de gebruiker vast te leggen.

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 klasse , wordt er een filterreeks gemaakt voor elke eigenschapswaarde die niet GetFilteredRows TableService null is. Vervolgens wordt een gecombineerde filterreeks gemaakt door alle waarden samen te brengen met een and-component. Deze gecombineerde filterreeks wordt doorgegeven aan de querymethode op het TableClient-object en alleen rijen die overeenkomen met de filterreeks worden geretourneerd. U kunt een vergelijkbare 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 behulp van een TableEntity-object

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

Wijzig de InsertTableEntity klasse 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 behulp van een TableEntity-object

Als u probeert een rij in te voegen in een tabel met een combinatie van partitiesleutel/rijsleutel die al in die tabel bestaat, wordt er een foutbericht weergegeven. Daarom is het vaak beter om de methode UpsertEntity te gebruiken in plaats van de addEntity-methode bij het toevoegen van rijen aan een tabel. Als de opgegeven combinatie van partitiesleutel/rijsleutel al in de tabel bestaat, 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 in een tabel wordt geladen nieuwe eigenschappen bevat, deze eigenschappen automatisch worden toegevoegd aan de tabel en de waarden die zijn opgeslagen in Cosmos DB. U hoeft geen DDL-instructies zoals ALTER TABLE 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 andere gegevens aan uw toepassing biedt. 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 wordt opgeslagen in de tabel, worden de bijbehorende eigenschappen (kolommen) automatisch toegevoegd aan de tabel.

In de voorbeeldtoepassing is de klasse gebouwd rond een interne woordenlijst ter ondersteuning van ExpandableWeatherObject een set eigenschappen van het object. Deze klasse vertegenwoordigt een typisch 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 Table-API, wijst u de eigenschappen van het uitbreidbare object toe aan een TableEntity-object en gebruikt u waar nodig de methoden AddEntity of UpsertEntity in het TableClient-object.

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 aan te roepen in het TableClient-object. Omdat een entiteit (rij) die is opgeslagen met behulp van de Table-API elke willekeurige set eigenschappen kan bevatten, is het vaak handig om een updateobject te maken op basis van een Dictionary-object dat vergelijkbaar is met het eerder besproken ExpandableWeatherObject object. In dit geval is het enige verschil de toevoeging van een eigenschap die wordt gebruikt voor Etag gelijktijdigheidscontrole 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 klasse TableService . Met deze methode wordt eerst de bestaande entiteit uit de Table-API met behulp van de Methode GetEntity in tableClient. Vervolgens wordt dat entiteitsobject bijgewerkt en wordt de UpdateEntity methode gebruikt om de updates op te slaan in de database. Houd er rekening mee dat de UpdateEntity-methode de huidige Etag van het object gebruikt om te voorkomen dat het object niet is gewijzigd sinds het voor het eerst is geladen. Als u de entiteit ongeacht 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, roept u de methode DeleteEntity op het TableClient-object aan met de partitiesleutel en rijsleutel van het object.

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

7 - De code uitvoeren

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

Een schermopname van de toepassing met de locatie van de knoppen die worden gebruikt om gegevens in Cosmos DB met behulp van tabel A 1.

Als u de knop Invoegen met behulp van tabelentiteit selecteert, wordt een dialoogvenster geopend waarin u een nieuwe rij kunt invoegen of upsert met behulp van een TableEntity -object.

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

Als u de knop Invoegen met uitbreidbare gegevens selecteert, wordt er een dialoogvenster weergegeven waarmee u een object met aangepaste eigenschappen kunt invoegen, waarin wordt gedemonstreert hoe de Cosmos DB Table-API automatisch eigenschappen (kolommen) aan de tabel toevoegt wanneer dat nodig is. Gebruik de knop Aangepast veld toevoegen om een of meer nieuwe eigenschappen toe te voegen en deze mogelijkheid te demonstreren.

Een schermopname 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 uw tabel Cosmos DB laden.

Een schermopname van de toepassing met de locatie van de knop voor het invoegen van voorbeeldgegevens.

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

Een schermopname van de toepassing met de pagina met filterresultaten en het markeren van het menu-item dat wordt gebruikt om naar de pagina te navigeren.

Resources opschonen

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

Een resourcegroep kan op de volgende Azure Portal worden verwijderd.

Instructies Schermopname
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 schermopname die laat zien hoe u naar een resourcegroep zoekt.
Selecteer Resourcegroep verwijderen op de werkbalk boven aan de pagina van de resourcegroep. Een schermopname van de locatie van de knop Resourcegroep verwijderen.
Er verschijnt een dialoogvenster aan de rechterkant van het scherm waarin u wordt gevraagd om de verwijdering van de resourcegroep te bevestigen.
  1. Typ de volledige naam van de resourcegroep in het tekstvak om de verwijdering te bevestigen, zoals wordt geïnstrueerd.
  2. Selecteer de knop Verwijderen onder aan de pagina.
Een schermopname van het bevestigingsvenster voor het verwijderen van een resourcegroep.

Volgende stappen

In deze Quick Start hebt u geleerd hoe u een Azure Cosmos DB-account kunt maken, hebt u een tabel gemaakt met de Data Explorer en hebt u een app uitgevoerd. Nu kunt u een query uitvoeren op uw gegevens met de Table-API.