Sdílet prostřednictvím

Migrace aplikace pro použití sady .NET SDK služby Azure Cosmos DB v3

  • Článek

PLATÍ PRO: NoSQL

Důležité

Další informace o sadě .NET SDK služby Azure Cosmos DB v3 najdete v poznámkách k verzi, úložišti .NET GitHub, tipech k výkonu sady .NET SDK v3 a průvodci odstraňováním potíží.

Tento článek popisuje některé aspekty upgradu stávající aplikace .NET na novější sadu .NET SDK služby Azure Cosmos DB verze 3 pro rozhraní API for NoSQL. Sada .NET SDK služby Azure Cosmos DB v3 odpovídá oboru názvů Microsoft.Azure.Azure Cosmos DB. Informace uvedené v tomto dokumentu můžete použít, pokud migrujete aplikaci z některé z následujících sad .NET SDK služby Azure Cosmos DB:

  • Sada .NET Framework SDK služby Azure Cosmos DB v2 pro rozhraní API pro NoSQL
  • Sada .NET Core SDK služby Azure Cosmos DB v2 pro rozhraní API pro NoSQL

Pokyny v tomto článku vám také pomůžou migrovat následující externí knihovny, které jsou teď součástí sady .NET SDK služby Azure Cosmos DB verze 3 pro rozhraní API for NoSQL:

  • Knihovna procesoru kanálu změn .NET 2.0
  • Knihovna bulk Executor .NET 1.1 nebo novější

Novinky v sadě .NET SDK V3

Sada SDK v3 obsahuje řadu vylepšení použitelnosti a výkonu, mezi která patří:

  • Intuitivní pojmenování programovacího modelu
  • .NET Standard 2.0 **
  • Zvýšení výkonu prostřednictvím podpory rozhraní API streamu
  • Fluent hierarchie, která nahrazuje potřebu továrny identifikátoru URI
  • Integrovaná podpora pro knihovnu procesoru kanálu změn
  • Integrovaná podpora hromadného provozu
  • Napodobené rozhraní API pro snadnější testování jednotek
  • Podpora transakční dávky a Blazoru
  • Připojitelné serializátory
  • Škálování kontejnerů bez dělení a automatického škálování

** Sada SDK cílí na .NET Standard 2.0, která sjednocuje stávající sady .NET Framework a sady .NET Core SDK služby Azure Cosmos DB do jedné sady .NET SDK. Sadu .NET SDK můžete použít v libovolné platformě, která implementuje .NET Standard 2.0, včetně aplikací .NET Framework 4.6.1 nebo novějších a .NET Core 2.0+.

Většina sítí, logiky opakování a nižších úrovní sady SDK zůstává z velké části nezměněná.

Sada .NET SDK služby Azure Cosmos DB v3 je teď open source. Vítáme všechny žádosti o přijetí změn a budeme zaznamenávat problémy s protokolováním a sledovat zpětnou vazbu na GitHubu. Budeme pracovat na všech funkcích, které zlepší uživatelské prostředí.

Proč migrovat na sadu .NET v3 SDK

Kromě řady vylepšení použitelnosti a výkonu se nové investice do funkcí provedené v nejnovější sadě SDK nepřevedou zpět do starších verzí. Sada SDK v2 je aktuálně v režimu údržby. Pro co nejlepší prostředí pro vývoj doporučujeme vždy začít s nejnovější podporovanou verzí sady SDK.

Změny hlavního názvu ze sady SDK v2 na sadu SDK v3

V sadě .NET 3.0 SDK byly použity následující změny názvů, které odpovídají konvencím pojmenování rozhraní API pro rozhraní API pro NoSQL:

  • DocumentClient přejmenová se na CosmosClient
  • Collection přejmenová se na Container
  • Document přejmenová se na Item

Všechny objekty prostředků se přejmenují s dalšími vlastnostmi, které zahrnují název prostředku pro přehlednost.

Tady jsou některé změny názvu hlavní třídy:

.NET v2 SDK Sada .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

Třídy nahrazené v sadě .NET v3 SDK

V sadě SDK verze 3.0 byly nahrazeny následující třídy:

  • Microsoft.Azure.Documents.UriFactory

Třída Microsoft.Azure.Documents.UriFactory byla nahrazena fluent designem.

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

Vzhledem k tomu, že sada .NET v3 SDK umožňuje uživatelům konfigurovat vlastní serializační modul, neexistuje žádná přímá náhrada typu Document . Při použití Newtonsoft.Json (výchozí modul serializace) JObject lze použít k dosažení stejné funkce. Při použití jiného modulu serializace můžete použít základní typ dokumentu JSON (například JsonDocument pro System.Text.Json). Doporučujeme použít typ jazyka C#, který odráží schéma položek, a nespoléhat se na obecné typy.

  • Microsoft.Azure.Documents.Resource

Neexistuje přímá náhrada , Resourcev případech, kdy byla použita pro dokumenty, postupujte podle pokynů pro Document.

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatch nebo IfMatch jsou nyní k dispozici Microsoft.Azure.Cosmos.ItemRequestOptions přímo.

Změny generování ID položky

ID položky se už automaticky nezaplní v sadě .NET SDK v3. ID položky proto musí obsahovat speciálně vygenerované ID. Podívejte se na následující příklad:

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

Změna výchozího chování režimu připojení

Sada SDK v3 teď ve výchozím nastavení v porovnání s předchozí sadou SDK v2 ve výchozím nastavení představuje režimy připojení Direct + TCP. Tato změna poskytuje vyšší výkon a škálovatelnost.

Změny v FeedOptions (QueryRequestOptions v 3.0 SDK)

Třída FeedOptions v sadě SDK v2 se teď přejmenovala na v sadě SDK v3 a v rámci této třídy došlo k QueryRequestOptions několika změnám názvu nebo výchozí hodnoty nebo byla zcela odebrána.

.NET v2 SDK Sada .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency – Výchozí hodnota a přidružené chování zůstávají stejné, operace spustí klientskou stranu během paralelního spouštění dotazů sériově bez paralelismu.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Chování je zachováno.
FeedOptions.EnableCrossPartitionQuery Odstraněný. Výchozí chování v sadě SDK 3.0 spočívá v tom, že se spustí dotazy napříč oddíly, aniž by bylo nutné povolit vlastnost konkrétně.
FeedOptions.PopulateQueryMetrics Odstraněný. Je teď ve výchozím nastavení povolená a je součástí diagnostiky.
FeedOptions.RequestContinuation Odstraněný. Nyní se propaguje na samotné metody dotazu.
FeedOptions.JsonSerializerSettings Odstraněný. Další informace najdete v tématu přizpůsobení serializace .
FeedOptions.PartitionKeyRangeId Odstraněný. Stejný výsledek lze získat pomocí FeedRange jako vstup do metody dotazu.
FeedOptions.DisableRUPerMinuteUsage Odstraněný.

Vytvoření klienta

Sada .NET SDK v3 poskytuje fluent CosmosClientBuilder třídu, která nahrazuje potřebu továrny identifikátorů URI sady SDK v2.

Fluent design vytváří adresy URL interně a umožňuje předání jednoho Container objektu místo DocumentClient, DatabaseNamea DocumentCollection.

Následující příklad vytvoří novou CosmosClientBuilder se silnou úrovní konzistence a seznamem upřednostňovaných umístění:

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

Výjimky

Kde sada SDK v2 používaná DocumentClientException k signalizaci chyb během operací používá CosmosExceptionsadu SDK v3, která zveřejňuje informace související s odpověďmi StatusCodeDiagnosticsa další informace související s odpověďmi. Všechny úplné informace jsou serializovány při ToString() použití:

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

Diagnostika

Pokud sada SDK v2 měla k dispozici diagnostiku pouze s přímým přístupem prostřednictvím RequestDiagnosticsString vlastnosti, používá Diagnostics sada SDK v3 dostupné ve všech odpovědích a výjimkách, které jsou bohatší a nejsou omezeny na přímý režim. Zahrnují nejen čas strávený sadou SDK pro operaci, ale také oblasti, na které se operace kontaktovala:

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

ConnectionPolicy

Některá nastavení ConnectionPolicy byla přejmenována nebo nahrazena CosmosClientOptions:

.NET v2 SDK Sada .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - Hodnota je nyní invertována, pokud EnableEndpointDiscovery byla nastavena na true, LimitToEndpoint měla by být nastavena na false. Před použitím tohoto nastavení musíte porozumět tomu, jak ovlivňuje klienta.
ConnectionProtocol Odstraněný. Protokol je svázaný s režimem, ať už se jedná o bránu (HTTPS) nebo direct (TCP). Přímý režim s protokolem HTTPS se už v sadě SDK V3 nepodporuje a doporučuje se použít protokol TCP.
MediaRequestTimeout Odstraněný. Přílohy se už nepodporují.
SetCurrentLocation CosmosClientOptions.ApplicationRegion lze použít k dosažení stejného efektu.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions lze použít k dosažení stejného efektu.
UserAgentSuffix CosmosClientBuilder.ApplicationName lze použít k dosažení stejného efektu.
UseMultipleWriteLocations Odstraněný. Sada SDK automaticky zjistí, jestli účet podporuje více koncových bodů zápisu.

Zásady indexování

V zásadách indexování není možné tyto vlastnosti konfigurovat. Pokud nezadáte, tyto vlastnosti budou mít vždy následující hodnoty:

Název vlastnosti Nová hodnota (není konfigurovatelná)
Kind range
dataType String a Number

V této části najdete příklady zásad indexování pro zahrnutí a vyloučení cest. Vzhledem k vylepšením v dotazovacím stroji nemá konfigurace těchto vlastností žádný vliv na výkon, i když používáte starší verzi sady SDK.

Token relace

Pokud sada SDK v2 vystavila token relace odpovědi v ResourceResponse.SessionToken případech, kdy bylo vyžadováno zachycení tokenu relace, protože token relace je hlavička, sada SDK v3 zveřejňuje tuto hodnotu ve Headers.Session vlastnosti jakékoli odpovědi.

Časové razítko

Pokud sada SDK v2 odhalila časové razítko dokumentu prostřednictvím Timestamp vlastnosti, protože Document už není k dispozici, mohou uživatelé mapovat _ts systémovou vlastnost na vlastnost v modelu.

OpenAsync

Pro případy použití, kdy OpenAsync() se používalo k zahřátí klienta sady SDK v2, CreateAndInitializeAsync je možné použít k vytvoření i zahřátí klienta sady SDK v3.

Použití rozhraní API procesoru kanálu změn přímo ze sady SDK v3

Sada SDK v3 má integrovanou podporu rozhraní API procesoru kanálu změn, která umožňuje používat stejnou sadu SDK pro sestavení aplikace a implementaci procesoru kanálu změn. Dříve jste museli použít samostatnou knihovnu procesoru kanálu změn.

Další informace najdete v tématu migrace z knihovny procesoru kanálu změn do sady .NET SDK služby Azure Cosmos DB v3.

Dotazy kanálu změn

Spouštění dotazů kanálu změn v sadě SDK v3 se považuje za použití modelu vyžádání kanálu změn. Pokud chcete migrovat konfiguraci, postupujte podle této tabulky:

.NET v2 SDK Sada .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange - K dosažení paralelismu čtení kanálu změn FeedRanges lze použít. Už není povinným parametrem. Teď můžete jednoduše číst kanál změn pro celý kontejner .
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey – Kanál FeedRange představující požadovaný klíč oddílu lze použít ke čtení kanálu změn pro tuto hodnotu klíče oddílu.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - Iterátor kanálu změn lze kdykoli zastavit a obnovit uložením pokračování a jeho použitím při vytváření nového iterátoru.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - Iterátor kanálu změn lze kdykoli zastavit a obnovit uložením pokračování a jeho použitím při vytváření nového iterátoru.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - Kanál změn je koncepčně nekonečný, takže by mohlo být vždy více výsledků. Pokud odpověď obsahuje stavový HttpStatusCode.NotModified kód, znamená to, že v tuto chvíli nejsou k dispozici žádné nové změny. Můžete ho použít k zastavení a uložení pokračování nebo k dočasnému spánku nebo čekání a dalším voláním otestujte ReadNextAsync nové změny.
Rozdělení zpracování Při čtení kanálu změn už není nutné, aby uživatelé zpracovávali rozdělené výjimky, rozdělení se bude zpracovávat transparentně bez nutnosti interakce uživatele.

Použití knihovny bulk executoru přímo ze sady SDK V3

Sada SDK v3 má integrovanou podporu pro knihovnu bulk executorů, která umožňuje používat stejnou sadu SDK pro sestavení aplikace a provádění hromadných operací. Dříve jste museli použít samostatnou knihovnu bulk executoru.

Další informace najdete v tématu migrace z knihovny Bulk Executor na hromadnou podporu v sadě .NET SDK služby Azure Cosmos DB v3.

Přizpůsobení serializace

Sada .NET SDK V2 umožňuje nastavení JsonSerializerSettings v RequestOptions na provozní úrovni použité k deserializaci výsledného dokumentu:

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

Sada .NET SDK v3 poskytuje rozhraní serializátoru pro úplné přizpůsobení serializačního modulu nebo více obecných možností serializace v rámci konstrukce klienta.

Přizpůsobení serializace na úrovni operace lze dosáhnout pomocí rozhraní API streamu:

// .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
        }
    }
}

Porovnání fragmentů kódu

Následující fragment kódu ukazuje rozdíly ve způsobu vytváření prostředků mezi sadami .NET v2 a v3 SDK:

Databázové operace

Vytvořit databázi 

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

Čtení databáze podle 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()}");
        }
    }
}

Odstranění databáze

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

Operace s kontejnery

Vytvoření kontejneru (automatické škálování + doba provozu s vypršením platnosti)

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

Čtení vlastností kontejneru

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

Odstranění kontejneru

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

Operace položek a dotazů

Vytvoření položky

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

Čtení všech položek v kontejneru

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

Dotazování položek

Změny v SqlQuerySpec (QueryDefinition v 3.0 SDK)

Třída SqlQuerySpec v sadě SDK v2 byla nyní přejmenována na QueryDefinition v sadě SDK v3.

SqlParameterCollection a SqlParameter byl odebrán. Parametry jsou nyní přidány do QueryDefinition modelu tvůrce pomocí QueryDefinition.WithParameter. Uživatelé mají přístup k parametrům pomocí 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);
        }
    }
}

Odstranění položky

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

Dotaz kanálu změn

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

Další kroky