Az alkalmazás migrálása az Azure Cosmos DB .NET SDK v3 használatára

  • Cikk

A KÖVETKEZŐRE VONATKOZIK: NoSQL

Fontos

Az Azure Cosmos DB .NET SDK v3-ról a Kibocsátási megjegyzések, a .NET GitHub-adattár, a .NET SDK v3 teljesítménytippek és a hibaelhárítási útmutató című témakörben olvashat.

Ez a cikk a meglévő .NET-alkalmazás noSQL-hez készült újabb Azure Cosmos DB .NET SDK v3-ra való frissítésének néhány szempontját ismerteti. Az Azure Cosmos DB .NET SDK v3 a Microsoft.Azure.Azure Cosmos DB névtérnek felel meg. Ha az alkalmazást az alábbi Azure Cosmos DB .NET SDK-k bármelyikéből migrálja, a jelen dokumentumban megadott információkat használhatja:

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

Az ebben a cikkben található utasítások az alábbi külső kódtárak migrálásában is segítenek, amelyek most már a NoSQL-hez készült Azure Cosmos DB .NET SDK v3 részét képezik:

  • .NET változáscsatorna processzortár 2.0
  • .NET tömeges végrehajtói kódtár 1.1 vagy újabb

A .NET V3 SDK újdonságai

A v3 SDK számos használhatósági és teljesítménybeli fejlesztést tartalmaz, többek között a következőket:

  • Intuitív programozási modell elnevezése
  • .NET Standard 2.0 **
  • Nagyobb teljesítmény stream API-támogatással
  • Fluent hierarchia, amely felváltja az URI-előállító szükségességét
  • Beépített támogatás változáscsatorna-feldolgozó kódtárhoz
  • Beépített támogatás tömeges műveletekhez
  • Mockable API-k a könnyebb egységtesztelés érdekében
  • Tranzakciós köteg és Blazor-támogatás
  • Csatlakoztatható szerializálók
  • Nem particionált és automatikus skálázású tárolók skálázása

** Az SDK a .NET Standard 2.0-t célozza meg, amely egyesíti a meglévő Azure Cosmos DB-.NET-keretrendszer és a .NET Core SDK-t egyetlen .NET SDK-vá. A .NET SDK-t bármely olyan platformon használhatja, amely a .NET Standard 2.0-t implementálja, beleértve a .NET-keretrendszer 4.6.1+ és a .NET Core 2.0+ alkalmazásokat is.

A hálózatkezelés, az újrapróbálkozási logika és az SDK alacsonyabb szintjei nagyrészt változatlanok maradnak.

Az Azure Cosmos DB .NET SDK v3 már nyílt forráskód. Örömmel fogadjuk a lekéréses kérelmeket, és naplózási problémákat tapasztalunk, és követjük a visszajelzéseket a GitHubon. Dolgozunk azon, hogy minden olyan funkciót átvessünk, amely javítja az ügyfélélményt.

Miért érdemes a .NET v3 SDK-ra migrálni?

A számos használhatósági és teljesítménybeli fejlesztés mellett a legújabb SDK-ban végrehajtott új funkcióberuházások nem lesznek visszahordva a régebbi verziókba. A v2 SDK jelenleg karbantartási módban van. A legjobb fejlesztési élmény érdekében javasoljuk, hogy mindig az SDK legújabb támogatott verziójával kezdjen.

Fő névváltozások v2 SDK-ról v3 SDK-ra

A .NET 3.0 SDK-n a következő névmódosítások lettek alkalmazva a NoSQL API-ra vonatkozó API-elnevezési konvenciókhoz való igazodáshoz:

  • DocumentClient átnevezve: CosmosClient
  • Collection átnevezve: Container
  • Document átnevezve: Item

A rendszer minden erőforrás-objektumot átnevez további tulajdonságokkal, amelyek tartalmazzák az erőforrás nevét az egyértelműség érdekében.

Az alábbiakban a főosztály nevének néhány változását íme néhány:

.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

A .NET v3 SDK-n lecserélt osztályok

A 3.0 SDK-n a következő osztályok lettek lecserélve:

  • Microsoft.Azure.Documents.UriFactory

A Microsoft.Azure.Documents.UriFactory osztályt felváltotta a fluent kialakítás.

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

Mivel a .NET v3 SDK lehetővé teszi, hogy a felhasználók egyéni szerializálási motort konfiguráljanak, nincs közvetlen csere a Document típusra. A Newtonsoft.Json (alapértelmezett szerializációs motor) JObject használata esetén ugyanezek a funkciók érhetők el. Ha másik szerializálási motort használ, használhatja annak alap json-dokumentumtípusát (például JsonDocument System.Text.Json esetén). A javaslat az, hogy olyan C#-típust használjon, amely az elemek sémáját tükrözi az általános típusok helyett.

  • Microsoft.Azure.Documents.Resource

A dokumentumokhoz Resourcehasznált esetekben nem történik közvetlen helyettesítés, kövesse a következőhöz tartozó útmutatást Document: .

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatchvagy IfMatch most már közvetlenül elérhetőek.Microsoft.Azure.Cosmos.ItemRequestOptions

Elemazonosító-létrehozás módosítása

Az elemazonosító már nem lesz automatikusan kitöltve a .NET v3 SDK-ban. Ezért az elemazonosítónak kifejezetten tartalmaznia kell egy generált azonosítót. Tekintse meg a következő példát:

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

A kapcsolati mód alapértelmezett viselkedésének módosítása

Az SDK v3 mostantól a Direct + TCP kapcsolati módokra vált az előző v2 SDK-hoz képest, amely alapértelmezés szerint Átjáró+ HTTPS-kapcsolati módokra lett alapértelmezés szerint. Ez a módosítás nagyobb teljesítményt és méretezhetőséget biztosít.

A FeedOptions (QueryRequestOptions in v3.0 SDK) változásai

Az FeedOptions SDK v2 osztályát átnevezték az SDK v3-ra QueryRequestOptions , és az osztályon belül több tulajdonság neve és/vagy alapértelmezett értéke módosult, vagy teljesen el lett távolítva.

.NET v2 SDK .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency – Az alapértelmezett érték és a társított viselkedés változatlan marad, a párhuzamos lekérdezés végrehajtása során az ügyféloldali műveleteket a rendszer soros módon, párhuzamosság nélkül hajtja végre.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Viselkedés karbantartva.
FeedOptions.EnableCrossPartitionQuery Eltávolítva. Az SDK 3.0 alapértelmezett viselkedése az, hogy a rendszer a partíciók közötti lekérdezéseket anélkül hajtja végre, hogy külön engedélyeznie kellene a tulajdonságot.
FeedOptions.PopulateQueryMetrics Eltávolítva. Alapértelmezés szerint engedélyezve van, és a diagnosztika része.
FeedOptions.RequestContinuation Eltávolítva. A lekérdezési metódusok mostantól maguk is előléptetik.
FeedOptions.JsonSerializerSettings Eltávolítva. További információkért tekintse meg, hogyan szabhatja testre a szerializálást .
FeedOptions.PartitionKeyRangeId Eltávolítva. Ugyanez az eredmény érhető el a FeedRange lekérdezési metódus bemeneteként való használatával.
FeedOptions.DisableRUPerMinuteUsage Eltávolítva.

Ügyfél létrehozása

A .NET SDK v3 egy fluent osztályt CosmosClientBuilder biztosít, amely felváltja az SDK v2 URI Factory szükségességét.

A fluent design belsőleg építi ki az URL-címeket, és lehetővé teszi egyetlen Container objektum átadását a DocumentClient, DatabaseNameés DocumentCollectionhelyett.

Az alábbi példa egy újat CosmosClientBuilder hoz létre erős Konzisztenciaszinttel és az előnyben részesített helyek listájával:

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

Kivételek

Ahol a v2 SDK a műveletek során előforduló hibák jelzésére szolgálDocumentClientException, a v3 SDK a , StatusCodeDiagnosticsés egyéb válaszokkal kapcsolatos információkat használjaCosmosException. Az összes teljes információ szerializálva van használatban ToString() :

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

Diagnosztika

Ha a v2 SDK-ban a tulajdonságon keresztül elérhető volt a RequestDiagnosticsString csak direct-only diagnosztikája, a v3 SDK Diagnostics minden válaszban és kivételben rendelkezésre áll, amelyek gazdagabbak, és nem korlátozódnak a Direct módra. Ezek nem csak a művelet SDK-ján töltött időt tartalmazzák, hanem a művelet által érintett régiókat is:

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

Egyes beállításokat ConnectionPolicy átneveztek vagy lecseréltek a következőre CosmosClientOptions:

.NET v2 SDK .NET v3 SDK
EnableEndpointRediscovery LimitToEndpoint– Az érték most invertált, ha EnableEndpointRediscovery a értékre van állítvatrue, LimitToEndpoint akkor a értékre kell állítani.false A beállítás használata előtt meg kell értenie, hogy ez hogyan érinti az ügyfelet.
ConnectionProtocol Eltávolítva. A protokoll a módhoz van kötve, legyen az átjáró (HTTPS) vagy közvetlen (TCP). A HTTPS protokollt használó közvetlen mód már nem támogatott a V3 SDK-n, és a TCP protokoll használata javasolt.
MediaRequestTimeout Eltávolítva. A mellékletek már nem támogatottak.
SetCurrentLocation CosmosClientOptions.ApplicationRegion egyazon hatás elérésére használható.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions egyazon hatás elérésére használható.
UserAgentSuffix CosmosClientBuilder.ApplicationName egyazon hatás elérésére használható.
UseMultipleWriteLocations Eltávolítva. Az SDK automatikusan észleli, ha a fiók több írási végpontot is támogat.

Indexelési szabályzat

Az indexelési szabályzatban nem lehet konfigurálni ezeket a tulajdonságokat. Ha nincs megadva, ezek a tulajdonságok mostantól mindig a következő értékekkel rendelkeznek:

Tulajdonság neve Új érték (nem konfigurálható)
Kind range
dataType String és Number

Ebben a szakaszban az elérési utak belefoglalására és kizárására vonatkozó házirend-példákat talál. A lekérdezési motor fejlesztései miatt ezeknek a tulajdonságoknak a konfigurálása még egy régebbi SDK-verzió használata esetén sem befolyásolja a teljesítményt.

Munkamenet-jogkivonat

Ha a v2 SDK közzétette egy válasz munkamenet-jogkivonatát, például ResourceResponse.SessionToken olyan esetekben, amikor a munkamenet-jogkivonat rögzítésére volt szükség, mivel a munkamenet-jogkivonat fejléc, a v3 SDK ezt az Headers.Session értéket bármely válasz tulajdonságában elérhetővé teszi.

Időbélyeg

Ha a v2 SDK közzétette egy dokumentum időbélyegét a Timestamp tulajdonságon keresztül, mert Document már nem érhető el, a felhasználók leképezhetik a rendszertulajdonságot a _ts modelljük egyik tulajdonságára.

OpenAsync

Olyan esetekben, amikor OpenAsync() a v2 SDK-ügyfél bemelegítésére használták, CreateAndInitializeAsync a v3 SDK-ügyfél létrehozására és bemelegítésére is használható.

A változáscsatorna-feldolgozó API-k használata közvetlenül a v3 SDK-ból

A v3 SDK beépített támogatást nyújt a Változáscsatorna-feldolgozó API-khoz, így ugyanazt az SDK-t használhatja az alkalmazás létrehozásához és a változáscsatorna feldolgozójának implementálásához. Korábban egy külön változáscsatorna-feldolgozó kódtárat kellett használnia.

További információ : Migrálás a változáscsatorna processzortárából az Azure Cosmos DB .NET v3 SDK-ba

Változáscsatorna-lekérdezések

A változáscsatorna-lekérdezések v3 SDK-n való végrehajtása a változáscsatorna lekérési modelljét használja. A konfiguráció áttelepítéséhez kövesse ezt a táblázatot:

.NET v2 SDK .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange - A párhuzamosság eléréséhez a változáscsatorna FeedRanges parancsai használhatók. Ez már nem kötelező paraméter, most már egyszerűen elolvashatja egy teljes tároló változáscsatornáját .
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey – A kívánt partíciókulcsot jelölő FeedRange használatával beolvasható az adott partíciókulcs-érték változáscsatornája.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation – A változáscsatorna-iterátor bármikor leállítható és folytatható a folytatás mentésével és új iterátor létrehozásakor történő használatával.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint – A változáscsatorna-iterátor bármikor leállítható és folytatható a folytatás mentésével és új iterátor létrehozásakor történő használatával.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - A változáscsatorna fogalmilag végtelen, így mindig lehet több eredmény. Ha egy válasz tartalmazza az HttpStatusCode.NotModified állapotkódot, az azt jelenti, hogy jelenleg nem kell új módosításokat olvasni. Ezzel leállíthatja és mentheti a folytatást , illetve ideiglenesen alvó állapotba helyezheti vagy várakozhat, majd újra felhívhatja ReadNextAsync az új módosítások teszteléséhez.
Felosztás kezelése A változáscsatorna olvasásakor már nem szükséges a felhasználóknak kezelni a felosztási kivételeket, a felosztások átláthatóan, felhasználói beavatkozás nélkül lesznek kezelve.

A tömeges végrehajtói kódtár használata közvetlenül a V3 SDK-ból

A v3 SDK beépített támogatást nyújt a tömeges végrehajtói kódtárhoz, így ugyanazt az SDK-t használhatja az alkalmazás létrehozásához és tömeges műveletek végrehajtásához. Korábban külön tömeges végrehajtói kódtárat kellett használnia.

További információ : Migrálás tömeges végrehajtói kódtárból tömeges támogatásba az Azure Cosmos DB .NET V3 SDK-ban

Szerializálás testreszabása

A .NET V2 SDK lehetővé teszi a JsonSerializerSettings beállítását a RequestOptionsban az eredménydokumentum deszerializálásához használt működési szinten:

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

A .NET SDK v3 egy szerializáló felületet biztosít a szerializálási motor teljes testreszabásához, vagy általánosabb szerializálási lehetőségeket az ügyfélépítés részeként.

A szerializálás műveleti szinten történő testreszabása Stream API-k használatával valósítható meg:

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

Kódrészletek összehasonlítása

Az alábbi kódrészlet az erőforrások .NET v2 és v3 SDK-k közötti létrehozásának különbségeit mutatja be:

Adatbázis-műveletek

Adatbázis létrehozása

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

Adatbázis beolvasása azonosító alapján

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

Adatbázis törlése

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

Tárolóműveletek

Tároló létrehozása (automatikus skálázás + élettartam lejárattal)

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

Tároló tulajdonságainak olvasása

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

Tároló törlése

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

Elem- és lekérdezésműveletek

Elem létrehozása

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

Egy tároló összes elemének olvasása

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

Elemek lekérdezése

Az SqlQuerySpec módosításai (QueryDefinition a 3.0-s verziójú SDK-ban)

Az SqlQuerySpec SDK v2 osztályát átnevezték az SDK v3-ra QueryDefinition .

SqlParameterCollection és SqlParameter el lett távolítva. A paraméterek mostantól hozzá lesznek adva egy szerkesztőmodellhez a QueryDefinition használatával QueryDefinition.WithParameter. A felhasználók a következővel érhetik el a paramétereket: 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);
        }
    }
}

Elem törlése

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

Változáscsatorna-lekérdezés

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

Következő lépések