Share via

Uw toepassing migreren om de Azure Cosmos DB .NET SDK v3 te gebruiken

  • Artikel

VAN TOEPASSING OP: NoSQL

Belangrijk

Zie de releaseopmerkingen, de .NET GitHub-opslagplaats, .NET SDK v3 Prestatietips en de gids voor probleemoplossing voor meer informatie over de Azure Cosmos DB .NET SDK v3 v3.

In dit artikel worden enkele overwegingen beschreven voor het upgraden van uw bestaande .NET-toepassing naar de nieuwere Azure Cosmos DB .NET SDK v3 for API for NoSQL. Azure Cosmos DB .NET SDK v3 komt overeen met de microsoft.Azure.Azure Cosmos DB-naamruimte. U kunt de informatie in dit document gebruiken als u uw toepassing migreert vanuit een van de volgende Azure Cosmos DB .NET SDK's:

  • Azure Cosmos DB .NET Framework SDK v2 for API for NoSQL
  • Azure Cosmos DB .NET Core SDK v2 for API for NoSQL

De instructies in dit artikel helpen u ook bij het migreren van de volgende externe bibliotheken die nu deel uitmaken van de Azure Cosmos DB .NET SDK v3 for API for NoSQL:

  • .NET-processorbibliotheek voor wijzigingenfeed 2.0
  • .NET bulkexecutorbibliotheek 1.1 of hoger

Wat is er nieuw in de .NET V3 SDK

De v3 SDK bevat veel bruikbaarheids- en prestatieverbeteringen, waaronder:

  • Naamgeving van intuïtief programmeermodel
  • .NET Standard 2.0 **
  • Verbeterde prestaties via stream-API-ondersteuning
  • Fluent-hiërarchie die de behoefte aan URI-factory vervangt
  • Ingebouwde ondersteuning voor de processorbibliotheek voor wijzigingenfeeds
  • Ingebouwde ondersteuning voor bulkbewerkingen
  • Mockable API's voor eenvoudigere eenheidstests
  • Transactionele batch- en Blazor-ondersteuning
  • Pluggable serializers
  • Containers die niet zijn gepartitioneerd en automatisch schalen

** De SDK is gericht op .NET Standard 2.0 waarmee de bestaande Azure Cosmos DB .NET Framework- en .NET Core SDK's worden samengevoegd tot één .NET SDK. U kunt de .NET SDK gebruiken in elk platform dat .NET Standard 2.0 implementeert, inclusief uw .NET Framework 4.6.1+ en .NET Core 2.0+-toepassingen.

De meeste netwerken, logica voor opnieuw proberen en lagere niveaus van de SDK blijven grotendeels ongewijzigd.

De Azure Cosmos DB .NET SDK v3 is nu open source. We verwelkomen alle pull-aanvragen en registreren problemen en het bijhouden van feedback op GitHub. We werken aan het overnemen van functies die de klantervaring verbeteren.

Waarom migreren naar de .NET v3 SDK

Naast de talloze bruikbaarheids- en prestatieverbeteringen, worden nieuwe functie-investeringen in de nieuwste SDK niet teruggezet naar oudere versies. De v2 SDK bevindt zich momenteel in de onderhoudsmodus. Voor de beste ontwikkelervaring raden we u aan altijd te beginnen met de nieuwste ondersteunde versie van SDK.

Belangrijke naamwijzigingen van v2 SDK naar v3 SDK

De volgende naamwijzigingen zijn toegepast in de .NET 3.0 SDK, zodat deze overeenkomt met de API-naamconventies voor de API voor NoSQL:

  • DocumentClient is hernoemd in CosmosClient
  • Collection is hernoemd in Container
  • Document is hernoemd in Item

Alle resourceobjecten worden hernoemd met aanvullende eigenschappen, waaronder de resourcenaam ter duidelijkheid.

Hier volgen enkele wijzigingen in de naam van de hoofdklasse:

.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

Klassen vervangen in .NET v3 SDK

De volgende klassen zijn vervangen in de 3.0 SDK:

  • Microsoft.Azure.Documents.UriFactory

De klasse Microsoft.Azure.Documents.UriFactory is vervangen door het vloeiende ontwerp.

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

Omdat met de .NET v3 SDK gebruikers een aangepaste serialisatie-engine kunnen configureren, is er geen directe vervanging voor het Document type. Wanneer u Newtonsoft.Json (standaardserialisatie-engine) gebruikt, JObject kunt u dezelfde functionaliteit bereiken. Wanneer u een andere serialisatie-engine gebruikt, kunt u het JSON-basisdocumenttype (bijvoorbeeld JsonDocument voor System.Text.Json) gebruiken. De aanbeveling is om een C#-type te gebruiken dat het schema van uw items weerspiegelt in plaats van te vertrouwen op algemene typen.

  • Microsoft.Azure.Documents.Resource

Er is geen directe vervanging voor Resource, in gevallen waarin het voor documenten is gebruikt, volgt u de richtlijnen voor Document.

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatch of IfMatch zijn nu rechtstreeks beschikbaar op de Microsoft.Azure.Cosmos.ItemRequestOptions pagina.

Wijzigingen in het genereren van item-id's

Item-id wordt niet meer automatisch ingevuld in de .NET v3 SDK. Daarom moet de item-id specifiek een gegenereerde id bevatten. Bekijk het volgende voorbeeld:

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

Standaardgedrag voor verbindingsmodus gewijzigd

De SDK v3 is nu standaard ingesteld op Direct + TCP-verbindingsmodi in vergelijking met de vorige v2 SDK, die standaard is ingesteld op gateway + HTTPS-verbindingsmodi. Deze wijziging biedt verbeterde prestaties en schaalbaarheid.

Wijzigingen in FeedOptions (QueryRequestOptions in v3.0 SDK)

De FeedOptions klasse in SDK v2 is nu gewijzigd QueryRequestOptions in de SDK v3 en binnen de klasse zijn verschillende eigenschappen gewijzigd in de naam en/of standaardwaarde of zijn volledig verwijderd.

.NET v2 SDK .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency - De standaardwaarde en het bijbehorende gedrag blijven hetzelfde, bewerkingen die worden uitgevoerd aan de clientzijde tijdens parallelle uitvoering van query's, worden serieel uitgevoerd zonder parallelle uitvoering.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Gedrag gehandhaafd.
FeedOptions.EnableCrossPartitionQuery Verwijderd. Standaardgedrag in SDK 3.0 is dat query's tussen partities worden uitgevoerd zonder dat de eigenschap specifiek hoeft te worden ingeschakeld.
FeedOptions.PopulateQueryMetrics Verwijderd. Deze is nu standaard ingeschakeld en maakt deel uit van de diagnostische gegevens.
FeedOptions.RequestContinuation Verwijderd. Het wordt nu gepromoveerd naar de querymethoden zelf.
FeedOptions.JsonSerializerSettings Verwijderd. Zie hoe u serialisatie aanpast voor aanvullende informatie.
FeedOptions.PartitionKeyRangeId Verwijderd. Hetzelfde resultaat kan worden verkregen van het gebruik van FeedRange als invoer voor de querymethode.
FeedOptions.DisableRUPerMinuteUsage Verwijderd.

Een client maken

De .NET SDK v3 biedt een fluent-klasse CosmosClientBuilder die de noodzaak voor de SDK v2 URI Factory vervangt.

Met het fluent-ontwerp worden URL's intern gebouwd en kan één Container object worden doorgegeven in plaats van een DocumentClient, DatabaseNameen DocumentCollection.

In het volgende voorbeeld wordt een nieuwe CosmosClientBuilder gemaakt met een sterk ConsistencyLevel en een lijst met voorkeurslocaties:

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

Uitzonderingen

Waar de v2 SDK die wordt gebruikt DocumentClientException om fouten tijdens bewerkingen aan te geven, gebruikt CosmosExceptionde v3 SDK , die de StatusCode, Diagnosticsen andere antwoordgerelateerde informatie weergeeft. Alle volledige informatie wordt geserialiseerd wanneer ToString() deze wordt gebruikt:

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

Diagnostiek

Waar de v2 SDK alleen-directe diagnostische gegevens beschikbaar had via de RequestDiagnosticsString eigenschap, gebruikt de v3 SDK alle Diagnostics antwoorden en uitzonderingen, die uitgebreider zijn en niet beperkt zijn tot de directe modus. Ze omvatten niet alleen de tijd die is besteed aan de SDK voor de bewerking, maar ook de regio's met wie contact is opgenomen:

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

Sommige instellingen in ConnectionPolicy zijn hernoemd of vervangen door CosmosClientOptions:

.NET v2 SDK .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - De waarde wordt nu omgekeerd, als EnableEndpointDiscovery deze is ingesteld op true, LimitToEndpoint moet worden ingesteld op false. Voordat u deze instelling gebruikt, moet u weten hoe deze van invloed is op de client.
ConnectionProtocol Verwijderd. Protocol is gekoppeld aan de modus, ofwel gateway (HTTPS) of Direct (TCP). De directe modus met het HTTPS-protocol wordt niet meer ondersteund in V3 SDK en het wordt aanbevolen TCP-protocol te gebruiken.
MediaRequestTimeout Verwijderd. Bijlagen worden niet meer ondersteund.
SetCurrentLocation CosmosClientOptions.ApplicationRegion kan worden gebruikt om hetzelfde effect te bereiken.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions kan worden gebruikt om hetzelfde effect te bereiken.
UserAgentSuffix CosmosClientBuilder.ApplicationName kan worden gebruikt om hetzelfde effect te bereiken.
UseMultipleWriteLocations Verwijderd. De SDK detecteert automatisch of het account ondersteuning biedt voor meerdere schrijfeindpunten.

Indexeringsbeleid

In het indexeringsbeleid is het niet mogelijk om deze eigenschappen te configureren. Wanneer deze niet zijn opgegeven, hebben deze eigenschappen nu altijd de volgende waarden:

Naam van eigenschap Nieuwe waarde (niet configureerbaar)
Kind range
dataType String en Number

Zie deze sectie voor voorbeelden van indexeringsbeleid voor het opnemen en uitsluiten van paden. Vanwege verbeteringen in de query-engine heeft het configureren van deze eigenschappen, zelfs als u een oudere SDK-versie gebruikt, geen invloed op de prestaties.

Sessietoken

Waar de v2 SDK het sessietoken van een antwoord beschikbaar heeft gesteld voor ResourceResponse.SessionToken gevallen waarin het vastleggen van het sessietoken vereist was, omdat het sessietoken een header is, toont de v3 SDK die waarde in de Headers.Session eigenschap van een antwoord.

Tijdstempel

Waar de v2 SDK de tijdstempel van een document via de Timestamp eigenschap beschikbaar heeft gesteld, omdat Document ze niet meer beschikbaar zijn, kunnen gebruikers de _ts systeemeigenschap toewijzen aan een eigenschap in hun model.

OpenAsync

Voor gebruiksscenario's waarbij OpenAsync() de v2 SDK-client werd opgewarmd, CreateAndInitializeAsync kan worden gebruikt om zowel een v3 SDK-client te maken als op te warmen .

De processor-API's van de wijzigingenfeed rechtstreeks gebruiken vanuit de v3 SDK

De v3 SDK heeft ingebouwde ondersteuning voor de API's voor wijzigingenfeedprocessor, zodat u dezelfde SDK kunt gebruiken voor het bouwen van uw toepassing en implementatie van de wijzigingenfeedprocessor. Voorheen moest u een afzonderlijke processorbibliotheek voor wijzigingenfeeds gebruiken.

Zie voor meer informatie hoe u migreert van de processorbibliotheek van de wijzigingenfeed naar de Azure Cosmos DB .NET v3 SDK

Query's voor wijzigingenfeed

Het uitvoeren van query's voor wijzigingenfeeds op de v3 SDK wordt beschouwd als het gebruik van het pull-model voor de wijzigingenfeed. Volg deze tabel om de configuratie te migreren:

.NET v2 SDK .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange- Om parallellisme te bereiken dat de FeedRanges voor wijzigingenfeeds kan worden gelezen, kan worden gebruikt. Het is geen vereiste parameter meer. U kunt de wijzigingenfeed nu eenvoudig lezen voor een hele container .
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey- Een FeedRange die de gewenste partitiesleutel vertegenwoordigt, kan worden gebruikt om de wijzigingenfeed voor die partitiesleutelwaarde te lezen.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - De iterator van de wijzigingenfeed kan op elk gewenst moment worden gestopt en hervat door de voortzetting op te slaan en te gebruiken bij het maken van een nieuwe iterator.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - De iterator van de wijzigingenfeed kan op elk gewenst moment worden gestopt en hervat door de voortzetting op te slaan en te gebruiken bij het maken van een nieuwe iterator.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - De wijzigingenfeed is conceptueel oneindig, dus er kunnen altijd meer resultaten zijn. Wanneer een antwoord de HttpStatusCode.NotModified statuscode bevat, betekent dit dat er op dit moment geen nieuwe wijzigingen zijn om te lezen. U kunt dit gebruiken om de voortzetting te stoppen en op te slaan of tijdelijk te slapen of te wachten en vervolgens opnieuw aan te roepen ReadNextAsync om te testen op nieuwe wijzigingen.
Split handling Het is niet meer nodig voor gebruikers om gesplitste uitzonderingen af te handelen bij het lezen van de wijzigingenfeed. Splitsingen worden transparant afgehandeld zonder tussenkomst van de gebruiker.

De bulkexecutorbibliotheek rechtstreeks vanuit de V3 SDK gebruiken

De v3 SDK biedt ingebouwde ondersteuning voor de bulkexecutorbibliotheek, zodat u dezelfde SDK kunt gebruiken voor het bouwen van uw toepassing en het uitvoeren van bulkbewerkingen. Voorheen moest u een afzonderlijke bulkexecutorbibliotheek gebruiken.

Zie voor meer informatie hoe u migreert van de bulkexecutorbibliotheek naar bulkondersteuning in Azure Cosmos DB .NET V3 SDK

Serialisatie aanpassen

Met de .NET V2 SDK kunt u JsonSerializerSettings instellen in RequestOptions op operationeel niveau dat wordt gebruikt om het resultaatdocument te deserialiseren:

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

De .NET SDK v3 biedt een serialisatie-interface voor het volledig aanpassen van de serialisatie-engine of meer algemene serialisatieopties als onderdeel van de clientconstructie.

Het aanpassen van de serialisatie op bewerkingsniveau kan worden bereikt door gebruik te maken van Stream-API's:

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

Vergelijkingen van codefragmenten

In het volgende codefragment ziet u de verschillen in de manier waarop resources worden gemaakt tussen de SDK's voor .NET v2 en v3:

Databasebewerkingen

Een -database maken

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

Een database lezen op 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()}");
        }
    }
}

Een database verwijderen

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

Containerbewerkingen

Een container maken (automatisch schalen en time to live met verlooptijd)

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

Containereigenschappen lezen

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

Een container verwijderen

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

Item- en querybewerkingen

Een item maken

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

Alle items in een container lezen

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

Query-items

Wijzigingen in SqlQuerySpec (QueryDefinition in v3.0 SDK)

De SqlQuerySpec klasse in SDK v2 is nu gewijzigd QueryDefinition in de SDK v3.

SqlParameterCollection en SqlParameter is verwijderd. Parameters worden nu toegevoegd aan het QueryDefinition model met behulp van QueryDefinition.WithParametereen opbouwfunctiemodel. Gebruikers hebben toegang tot de parameters met 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);
        }
    }
}

Een item verwijderen

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

Wijzigingenfeedquery

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

Volgende stappen