Migrera ditt program för att använda Azure Cosmos DB .NET SDK v3

  • Artikel

GÄLLER FÖR: NoSQL

Viktigt!

Mer information om Azure Cosmos DB .NET SDK v3 finns i Viktig information, .NET GitHub-lagringsplatsen, prestandatips för .NET SDK v3 och felsökningsguiden.

Den här artikeln beskriver några av övervägandena när du uppgraderar ditt befintliga .NET-program till nyare Azure Cosmos DB .NET SDK v3 för API för NoSQL. Azure Cosmos DB .NET SDK v3 motsvarar namnområdet Microsoft.Azure.Azure Cosmos DB. Du kan använda informationen i det här dokumentet om du migrerar ditt program från någon av följande Azure Cosmos DB .NET SDK:er:

  • Azure Cosmos DB .NET Framework SDK v2 för API för NoSQL
  • Azure Cosmos DB .NET Core SDK v2 för API för NoSQL

Anvisningarna i den här artikeln hjälper dig också att migrera följande externa bibliotek som nu ingår i Azure Cosmos DB .NET SDK v3 för API för NoSQL:

  • .NET-ändringsflödesprocessorbibliotek 2.0
  • .NET massexekutorbibliotek 1.1 eller senare

Nyheter i .NET V3 SDK

V3 SDK innehåller många förbättringar av användbarhet och prestanda, inklusive:

  • Namngivning av intuitiv programmeringsmodell
  • .NET Standard 2.0 **
  • Ökad prestanda via stöd för stream-API
  • Fluent-hierarki som ersätter behovet av URI-fabrik
  • Inbyggt stöd för ändringsflödesprocessorbibliotek
  • Inbyggt stöd för massåtgärder
  • Modellerbara API:er för enklare enhetstestning
  • Stöd för transaktionsbatch och Blazor
  • Serialiserare som kan anslutas
  • Skala icke-partitionerade containrar och autoskalningscontainrar

** SDK:et riktar sig mot .NET Standard 2.0 som förenar befintliga Azure Cosmos DB .NET Framework- och .NET Core SDK:er till en enda .NET SDK. Du kan använda .NET SDK på valfri plattform som implementerar .NET Standard 2.0, inklusive dina .NET Framework 4.6.1+ och .NET Core 2.0+-program.

De flesta nätverk, återförsökslogik och lägre nivåer i SDK:n förblir i stort sett oförändrade.

Azure Cosmos DB .NET SDK v3 är nu öppen källkod. Vi välkomnar alla pull-begäranden och kommer att logga problem och spåra feedback på GitHub. Vi kommer att arbeta med att ta på oss alla funktioner som förbättrar kundupplevelsen.

Varför migrera till .NET v3 SDK

Utöver de många förbättringarna av användbarhet och prestanda kommer nya funktionsinvesteringar som gjorts i den senaste SDK:n inte att vara tillbaka portade till äldre versioner. V2 SDK är för närvarande i underhållsläge. För bästa möjliga utvecklingsupplevelse rekommenderar vi att du alltid börjar med den senaste versionen av SDK som stöds.

Större namnändringar från v2 SDK till v3 SDK

Följande namnändringar har tillämpats i .NET 3.0 SDK för att överensstämma med API-namngivningskonventionerna för API:et för NoSQL:

  • DocumentClient har bytt namn till CosmosClient
  • Collection har bytt namn till Container
  • Document har bytt namn till Item

Alla resursobjekt byt namn med ytterligare egenskaper, vilket innehåller resursnamnet för tydlighetens skull.

Följande är några av de viktigaste klassnamnsändringarna:

.NET v2 SDK .NET v3 SDK
Microsoft.Azure.Documents.Client.DocumentClient Microsoft.Azure.Cosmos.CosmosClient
Microsoft.Azure.Documents.Client.ConnectionPolicy Microsoft.Azure.Cosmos.CosmosClientOptions
Microsoft.Azure.Documents.Client.DocumentClientException Microsoft.Azure.Cosmos.CosmosException
Microsoft.Azure.Documents.Client.Database Microsoft.Azure.Cosmos.DatabaseProperties
Microsoft.Azure.Documents.Client.DocumentCollection Microsoft.Azure.Cosmos.ContainerProperties
Microsoft.Azure.Documents.Client.RequestOptions Microsoft.Azure.Cosmos.ItemRequestOptions
Microsoft.Azure.Documents.Client.FeedOptions Microsoft.Azure.Cosmos.QueryRequestOptions
Microsoft.Azure.Documents.Client.StoredProcedure Microsoft.Azure.Cosmos.StoredProcedureProperties
Microsoft.Azure.Documents.Client.Trigger Microsoft.Azure.Cosmos.TriggerProperties
Microsoft.Azure.Documents.SqlQuerySpec Microsoft.Azure.Cosmos.QueryDefinition

Klasser som ersatts på .NET v3 SDK

Följande klasser har ersatts på SDK:et 3.0:

  • Microsoft.Azure.Documents.UriFactory

Klassen Microsoft.Azure.Documents.UriFactory har ersatts av fluent-designen.

Container container = client.GetContainer(databaseName,containerName);
ItemResponse<SalesOrder> response = await this._container.CreateItemAsync(
        salesOrder,
        new PartitionKey(salesOrder.AccountNumber));
  • Microsoft.Azure.Documents.Document

Eftersom .NET v3 SDK tillåter användare att konfigurera en anpassad serialiseringsmotor, finns det ingen direkt ersättning för Document typen. När du använder Newtonsoft.Json (standard serialiseringsmotor) JObject kan du använda för att uppnå samma funktioner. När du använder en annan serialiseringsmotor kan du använda dess grundläggande json-dokumenttyp (till exempel JsonDocument för System.Text.Json). Rekommendationen är att använda en C#-typ som återspeglar schemat för dina objekt i stället för att förlita sig på generiska typer.

  • Microsoft.Azure.Documents.Resource

Det finns ingen direkt ersättning för Resource, i de fall där den användes för dokument följer du vägledningen för Document.

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatch eller IfMatch är nu tillgängliga Microsoft.Azure.Cosmos.ItemRequestOptions direkt.

Ändringar i objekt-ID-generering

Objekt-ID fylls inte längre i automatiskt i .NET v3 SDK. Därför måste objekt-ID:t specifikt innehålla ett genererat ID. Visa följande exempel:

[JsonProperty(PropertyName = "id")]
public Guid Id { get; set; }

Standardbeteendet för anslutningsläge har ändrats

SDK v3 är nu som standard Direct + TCP-anslutningslägen jämfört med föregående V2 SDK, som standard är Gateway + HTTPS-anslutningslägen. Den här ändringen ger bättre prestanda och skalbarhet.

Ändringar i FeedOptions (QueryRequestOptions i v3.0 SDK)

Klassen FeedOptions i SDK v2 har nu bytt namn till QueryRequestOptions i SDK v3 och i klassen har flera egenskaper haft ändringar i namn och/eller standardvärde eller tagits bort helt.

.NET v2 SDK .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency – Standardvärdet och det associerade beteendet är detsamma, åtgärder som körs på klientsidan under parallell frågekörning körs seriellt utan parallellitet.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Beteende upprätthålls.
FeedOptions.EnableCrossPartitionQuery Bort. Standardbeteendet i SDK 3.0 är att frågor mellan partitioner körs utan att du behöver aktivera egenskapen specifikt.
FeedOptions.PopulateQueryMetrics Bort. Den är nu aktiverad som standard och en del av diagnostiken.
FeedOptions.RequestContinuation Bort. Den har nu befordrats till själva frågemetoderna.
FeedOptions.JsonSerializerSettings Bort. Mer information finns i anpassa serialisering .
FeedOptions.PartitionKeyRangeId Bort. Samma resultat kan hämtas från att använda FeedRange som indata till frågemetoden.
FeedOptions.DisableRUPerMinuteUsage Bort.

Skapa en klient

.NET SDK v3 tillhandahåller en fluent-klass CosmosClientBuilder som ersätter behovet av SDK v2 URI Factory.

Fluent-designen skapar URL:er internt och gör att ett enda Container objekt kan skickas runt i stället för , DocumentClientDatabaseNameoch DocumentCollection.

I följande exempel skapas en ny CosmosClientBuilder med en stark ConsistencyLevel och en lista över önskade platser:

CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
    accountEndpoint: "https://testcosmos.documents.azure.com:443/",
    authKeyOrResourceToken: "SuperSecretKey")
.WithConsistencyLevel(ConsistencyLevel.Strong)
.WithApplicationRegion(Regions.EastUS);
CosmosClient client = cosmosClientBuilder.Build();

Undantag

Om v2 SDK används DocumentClientException för att signalera fel under åtgärder använder CosmosExceptionv3 SDK , som exponerar , Diagnosticsoch annan svarsrelaterad StatusCodeinformation. All fullständig information serialiseras när ToString() används:

catch (CosmosException ex)
{
    HttpStatusCode statusCode = ex.StatusCode;
    CosmosDiagnostics diagnostics = ex.Diagnostics;
    // store diagnostics optionally with diagnostics.ToString();
    // or log the entire error details with ex.ToString();
}

Diagnostik

Om v2 SDK hade direktdiagnostik tillgänglig via RequestDiagnosticsString egenskapen använder Diagnostics V3 SDK tillgänglig i alla svar och undantag, som är rikare och inte begränsade till direktläge. De omfattar inte bara den tid som lagts på SDK:t för åtgärden, utan även de regioner som åtgärden kontaktade:

try
{
    ItemResponse<MyItem> response = await container.ReadItemAsync<MyItem>(
                    partitionKey: new PartitionKey("MyPartitionKey"),
                    id: "MyId");
    
    TimeSpan elapsedTime = response.Diagnostics.GetElapsedTime();
    if (elapsedTime > somePreDefinedThreshold)
    {
        // log response.Diagnostics.ToString();
        IReadOnlyList<(string region, Uri uri)> regions = response.Diagnostics.GetContactedRegions();
    }
}
catch (CosmosException cosmosException) {
    string diagnostics = cosmosException.Diagnostics.ToString();
    
    TimeSpan elapsedTime = cosmosException.Diagnostics.GetElapsedTime();
    
    IReadOnlyList<(string region, Uri uri)> regions = cosmosException.Diagnostics.GetContactedRegions();
    
    // log cosmosException.ToString()
}

Anslut ionPolicy

Vissa inställningar i ConnectionPolicy har bytt namn eller ersatts av CosmosClientOptions:

.NET v2 SDK .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - Värdet är nu inverterat, om EnableEndpointDiscovery har angetts till true, LimitToEndpoint bör anges till false. Innan du använder den här inställningen måste du förstå hur den påverkar klienten.
ConnectionProtocol Bort. Protokollet är kopplat till läget, antingen gatewayen (HTTPS) eller direkt (TCP). Direktläge med HTTPS-protokoll stöds inte längre på V3 SDK och rekommendationen är att använda TCP-protokoll.
MediaRequestTimeout Bort. Bifogade filer stöds inte längre.
SetCurrentLocation CosmosClientOptions.ApplicationRegion kan användas för att uppnå samma effekt.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions kan användas för att uppnå samma effekt.
UserAgentSuffix CosmosClientBuilder.ApplicationName kan användas för att uppnå samma effekt.
UseMultipleWriteLocations Bort. SDK identifierar automatiskt om kontot stöder flera skrivslutpunkter.

Indexeringsprincip

I indexeringsprincipen går det inte att konfigurera dessa egenskaper. När de inte anges har de här egenskaperna alltid följande värden:

Egenskapsnamn Nytt värde (kan inte konfigureras)
Kind range
dataType String och Number

Se det här avsnittet för indexering av principexempel för att inkludera och exkludera sökvägar. På grund av förbättringar i frågemotorn påverkar inte konfigurationen av dessa egenskaper, även om du använder en äldre SDK-version, prestanda.

Sessionstoken

Om v2 SDK exponerade sessionstoken för ett svar som ResourceResponse.SessionToken för fall där insamling av sessionstoken krävdes, eftersom sessionstoken är en rubrik, exponerar v3 SDK det värdet i Headers.Session egenskapen för alla svar.

Tidsstämpel

Om v2 SDK exponerade tidsstämpeln för ett dokument via Timestamp egenskapen, eftersom Document den inte längre är tillgänglig, kan användarna mappa systemegenskapen _ts till en egenskap i sin modell.

OpenAsync

För användningsfall där OpenAsync() användes för att värma upp V2 SDK-klienten CreateAndInitializeAsync kan användas för att både skapa och värma upp en v3 SDK-klient.

Använda API:erna för ändringsflödesprocessorn direkt från v3 SDK

V3 SDK har inbyggt stöd för API:erna för ändringsflödesprocessor, så att du kan använda samma SDK för att skapa din program- och ändringsflödesprocessorimplementering. Tidigare var du tvungen att använda ett separat ändringsflödesprocessorbibliotek.

Mer information finns i migrera från biblioteket för ändringsflödesprocessor till Azure Cosmos DB .NET v3 SDK

Ändra feedfrågor

Körning av ändringsflödesfrågor på v3 SDK anses använda pull-modellen för ändringsflöde. Följ den här tabellen för att migrera konfigurationen:

.NET v2 SDK .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange – För att uppnå parallellitet kan du läsa ändringsflödet FeedRanges . Det är inte längre en obligatorisk parameter, du kan läsa ändringsflödet för en hel container enkelt nu.
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey – En FeedRange som representerar önskad partitionsnyckel kan användas för att läsa ändringsflödet för det partitionsnyckelvärdet.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - Iteratorn för ändringsflöde kan stoppas och återupptas när som helst genom att spara fortsättningen och använda den när du skapar en ny iterator.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - Iteratorn för ändringsflöde kan stoppas och återupptas när som helst genom att spara fortsättningen och använda den när du skapar en ny iterator.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - Ändringsflödet är konceptuellt oändligt, så det kan alltid finnas fler resultat. När ett svar innehåller HttpStatusCode.NotModified statuskoden innebär det att det inte finns några nya ändringar att läsa just nu. Du kan använda det för att stoppa och spara fortsättningen eller för att tillfälligt sova eller vänta och sedan anropa ReadNextAsync igen för att testa nya ändringar.
Delad hantering Det krävs inte längre att användarna hanterar delade undantag när de läser ändringsflödet, delningar hanteras transparent utan att användaren behöver interagera.

Använda massexekutorbiblioteket direkt från V3 SDK

V3 SDK har inbyggt stöd för massexekutorbiblioteket, så att du kan använda samma SDK för att skapa ditt program och utföra massåtgärder. Tidigare var du skyldig att använda ett separat massexekutorbibliotek.

Mer information finns i migrera från massexekutorbiblioteket till massstöd i Azure Cosmos DB .NET V3 SDK

Anpassa serialisering

Med .NET V2 SDK kan du ange JsonSerializer Inställningar i RequestOptions på den driftsnivå som används för att deserialisera resultatdokumentet:

// .NET V2 SDK
var result = await container.ReplaceDocumentAsync(document, new RequestOptions { JsonSerializerSettings = customSerializerSettings })

.NET SDK v3 tillhandahåller ett serialiserargränssnitt för att helt anpassa serialiseringsmotorn, eller mer generiska serialiseringsalternativ som en del av klientkonstruktionen.

Du kan anpassa serialiseringen på åtgärdsnivå genom att använda Stream-API:er:

// .NET V3 SDK
using(Response response = await this.container.ReplaceItemStreamAsync(stream, "itemId", new PartitionKey("itemPartitionKey"))
{

    using(Stream stream = response.ContentStream)
    {
        using (StreamReader streamReader = new StreamReader(stream))
        {
            // Read the stream and do dynamic deserialization based on type with a custom Serializer
        }
    }
}

Jämförelse av kodfragment

Följande kodfragment visar skillnaderna i hur resurser skapas mellan .NET v2 och v3 SDK:er:

Databasanvändning

Skapa en -databas

// Create database with no shared provisioned throughput
DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync(DatabaseName);
Database database = databaseResponse;
DatabaseProperties databaseProperties = databaseResponse;

// Create a database with a shared manual provisioned throughput
string databaseIdManual = new string(DatabaseName + "_SharedManualThroughput");
database = await client.CreateDatabaseIfNotExistsAsync(databaseIdManual, ThroughputProperties.CreateManualThroughput(400));

// Create a database with shared autoscale provisioned throughput
string databaseIdAutoscale = new string(DatabaseName + "_SharedAutoscaleThroughput");
database = await client.CreateDatabaseIfNotExistsAsync(databaseIdAutoscale, ThroughputProperties.CreateAutoscaleThroughput(4000));

Läsa en databas via ID

// Read a database
Console.WriteLine($"{Environment.NewLine} Read database resource: {DatabaseName}");
database = client.GetDatabase(DatabaseName);
Console.WriteLine($"{Environment.NewLine} database { database.Id.ToString()}");

// Read all databases
string findQueryText = "SELECT * FROM c";
using (FeedIterator<DatabaseProperties> feedIterator = client.GetDatabaseQueryIterator<DatabaseProperties>(findQueryText))
{
    while (feedIterator.HasMoreResults)
    {
        FeedResponse<DatabaseProperties> databaseResponses = await feedIterator.ReadNextAsync();
        foreach (DatabaseProperties _database in databaseResponses)
        {
            Console.WriteLine($"{ Environment.NewLine} database {_database.Id.ToString()}");
        }
    }
}

Ta bort en databas

// Delete a database
await client.GetDatabase(DatabaseName).DeleteAsync();
Console.WriteLine($"{ Environment.NewLine} database {DatabaseName} deleted.");

// Delete all databases in an account
string deleteQueryText = "SELECT * FROM c";
using (FeedIterator<DatabaseProperties> feedIterator = client.GetDatabaseQueryIterator<DatabaseProperties>(deleteQueryText))
{
    while (feedIterator.HasMoreResults)
    {
        FeedResponse<DatabaseProperties> databaseResponses = await feedIterator.ReadNextAsync();
        foreach (DatabaseProperties _database in databaseResponses)
        {
            await client.GetDatabase(_database.Id).DeleteAsync();
            Console.WriteLine($"{ Environment.NewLine} database {_database.Id} deleted");
        }
    }
}

Containeråtgärder

Skapa en container (Autoskalning + Tid att leva med förfallodatum)

private static async Task CreateManualThroughputContainer(Database database)
{
    // Set throughput to the minimum value of 400 RU/s manually configured throughput
    string containerIdManual = ContainerName + "_Manual";
    ContainerResponse container = await database.CreateContainerIfNotExistsAsync(
        id: containerIdManual,
        partitionKeyPath: partitionKeyPath,
        throughput: 400);
}

// Create container with autoscale
private static async Task CreateAutoscaleThroughputContainer(Database database)
{
    string autoscaleContainerId = ContainerName + "_Autoscale";
    ContainerProperties containerProperties = new ContainerProperties(autoscaleContainerId, partitionKeyPath);

    Container container = await database.CreateContainerIfNotExistsAsync(
        containerProperties: containerProperties,
        throughputProperties: ThroughputProperties.CreateAutoscaleThroughput(autoscaleMaxThroughput: 4000);
}

// Create a container with TTL Expiration
private static async Task CreateContainerWithTtlExpiration(Database database)
{
    string containerIdManualwithTTL = ContainerName + "_ManualTTL";

    ContainerProperties properties = new ContainerProperties
        (id: containerIdManualwithTTL,
        partitionKeyPath: partitionKeyPath);

    properties.DefaultTimeToLive = (int)TimeSpan.FromDays(1).TotalSeconds; //expire in 1 day

    ContainerResponse containerResponse = await database.CreateContainerIfNotExistsAsync(containerProperties: properties);
    ContainerProperties returnedProperties = containerResponse;
}

Läsa containeregenskaper

private static async Task ReadContainerProperties(Database database)
{
    string containerIdManual = ContainerName + "_Manual";
    Container container = database.GetContainer(containerIdManual);
    ContainerProperties containerProperties = await container.ReadContainerAsync();
}

Ta bort en container

private static async Task DeleteContainers(Database database)
{
    string containerIdManual = ContainerName + "_Manual";

    // Delete a container
    await database.GetContainer(containerIdManual).DeleteContainerAsync();

    // Delete all CosmosContainer resources for a database
    using (FeedIterator<ContainerProperties> feedIterator = database.GetContainerQueryIterator<ContainerProperties>())
    {
        while (feedIterator.HasMoreResults)
        {
            foreach (ContainerProperties _container in await feedIterator.ReadNextAsync())
            {
                await database.GetContainer(_container.Id).DeleteContainerAsync();
                Console.WriteLine($"{Environment.NewLine}  deleted container {_container.Id}");
            }
        }
    }
}

Objekt- och frågeåtgärder

Skapa ett objekt

private static async Task CreateItemAsync(Container container)
{
    // Create a SalesOrder POCO object
    SalesOrder salesOrder1 = GetSalesOrderSample("Account1", "SalesOrder1");
    ItemResponse<SalesOrder> response = await container.CreateItemAsync(salesOrder1,
        new PartitionKey(salesOrder1.AccountNumber));
}

private static async Task RunBasicOperationsOnDynamicObjects(Container container)
{
    // Dynamic Object
    dynamic salesOrder = new
    {
        id = "SalesOrder5",
        AccountNumber = "Account1",
        PurchaseOrderNumber = "PO18009186470",
        OrderDate = DateTime.UtcNow,
        Total = 5.95,
    };
    Console.WriteLine("\nCreating item");
    ItemResponse<dynamic> response = await container.CreateItemAsync<dynamic>(
        salesOrder, new PartitionKey(salesOrder.AccountNumber));
    dynamic createdSalesOrder = response.Resource;
}

Läsa alla objekt i en container

private static async Task ReadAllItems(Container container)
{
    // Read all items in a container
    List<SalesOrder> allSalesForAccount1 = new List<SalesOrder>();

    using (FeedIterator<SalesOrder> resultSet = container.GetItemQueryIterator<SalesOrder>(
        queryDefinition: null,
        requestOptions: new QueryRequestOptions()
        {
            PartitionKey = new PartitionKey("Account1"),
            MaxItemCount = 5
        }))
    {
        while (resultSet.HasMoreResults)
        {
            FeedResponse<SalesOrder> response = await resultSet.ReadNextAsync();
            SalesOrder salesOrder = response.First();
            Console.WriteLine($"\n1.3.1 Account Number: {salesOrder.AccountNumber}; Id: {salesOrder.Id}");
            allSalesForAccount1.AddRange(response);
        }
    }
}

Frågeobjekt

Ändringar i SqlQuerySpec (QueryDefinition i v3.0 SDK)

Klassen SqlQuerySpec i SDK v2 har nu bytt namn till QueryDefinition i SDK v3.

SqlParameterCollection och SqlParameter har tagits bort. Parametrar läggs nu till i QueryDefinition med en builder-modell med hjälp av QueryDefinition.WithParameter. Användare kan komma åt parametrarna med QueryDefinition.GetQueryParameters

private static async Task QueryItems(Container container)
{
    // Query for items by a property other than Id
    QueryDefinition queryDefinition = new QueryDefinition(
        "select * from sales s where s.AccountNumber = @AccountInput")
        .WithParameter("@AccountInput", "Account1");

    List<SalesOrder> allSalesForAccount1 = new List<SalesOrder>();
    using (FeedIterator<SalesOrder> resultSet = container.GetItemQueryIterator<SalesOrder>(
        queryDefinition,
        requestOptions: new QueryRequestOptions()
        {
            PartitionKey = new PartitionKey("Account1"),
            MaxItemCount = 1
        }))
    {
        while (resultSet.HasMoreResults)
        {
            FeedResponse<SalesOrder> response = await resultSet.ReadNextAsync();
            SalesOrder sale = response.First();
            Console.WriteLine($"\n Account Number: {sale.AccountNumber}; Id: {sale.Id};");
            allSalesForAccount1.AddRange(response);
        }
    }
}

Ta bort ett objekt

private static async Task DeleteItemAsync(Container container)
{
    ItemResponse<SalesOrder> response = await container.DeleteItemAsync<SalesOrder>(
        partitionKey: new PartitionKey("Account1"), id: "SalesOrder3");
}

Ändringsflödesfråga

private static async Task QueryChangeFeedAsync(Container container)
{
    FeedIterator<SalesOrder> iterator = container.GetChangeFeedIterator<SalesOrder>(ChangeFeedStartFrom.Beginning(), ChangeFeedMode.Incremental);

    string continuation = null;
    while (iterator.HasMoreResults)
    {
        FeedResponse<SalesOrder> response = await iteratorForTheEntireContainer.ReadNextAsync();
    
        if (response.StatusCode == HttpStatusCode.NotModified)
        {
            // No new changes
            continuation = response.ContinuationToken;
            break;
        }
        else 
        {
            // Process the documents in response
        }
    }
}

Nästa steg