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 kiadási megjegyzésekben, a .NET GitHub-adattárban, a .NET SDK v3 performance Tippek és a hibaelhárítási útmutatóban olvashat.

Ez a cikk kiemeli a meglévő .NET-alkalmazás frissítésének néhány szempontját az újabb Azure Cosmos DB .NET SDK v3 for API for NoSQL-re. 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, használhatja a dokumentumban megadott információkat:

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

A cikkben található utasítások az alábbi külső kódtárak migrálásához is segítséget nyújtanak, amelyek most már az Azure Cosmos DB .NET SDK v3 for API for NoSQL részét képezik:

  • .NET változáscsatorna processzortár 2.0
  • .NET bulk executor library 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-gyár szükségességét
  • Beépített támogatás a változáscsatorna processzortárához
  • Beépített támogatás tömeges műveletekhez
  • Modellezhető 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 méretezésű tárolók méretezése

** Az SDK a .NET Standard 2.0-t célozza meg, amely egyetlen .NET SDK-ra egyesíti a meglévő Azure Cosmos DB .NET-keretrendszer és a .NET Core SDK-t. 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ás logikája és az SDK alacsonyabb szintjei nagyrészt változatlanok maradnak.

Az Azure Cosmos DB .NET SDK v3 már nyílt forráskód. Üdvözöljük a lekéréses kérelmeket, és naplózási problémákat és visszajelzéseket követünk nyomon a GitHubon . Dolgozunk minden olyan funkción, amely javítja az ügyfélélményt.

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

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ókra. 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őbb 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, hogy igazodjanak a NoSQL API api-elnevezési konvencióihoz:

  • DocumentClient a átnevezve CosmosClient
  • Collection a átnevezve Container
  • Document a á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.

A főosztálynév néhány módosítása az alábbiak szerint változik:

.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álatakor 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 egy olyan C#-típus használata, amely az elemek sémáját tükrözi az általános típusok helyett.

  • Microsoft.Azure.Documents.Resource

Azokban az esetekben, amikor dokumentumokhoz használták , nincs közvetlen helyettesítés Resource, kövesse a következő útmutatást Document: .

  • Microsoft.Azure.Documents.AccessCondition

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

Az 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 alapértelmezés szerint Direct + TCP kapcsolati módra vált az előző v2 SDK-hoz képest, amely alapértelmezés szerint átjáró+ HTTPS-kapcsolati módokra lett beállítva. 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 is módosult a névben és/vagy az alapértelmezett értékben, 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 sorosan, párhuzamosság nélkül hajtja végre.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Viselkedés megtartva.
FeedOptions.EnableCrossPartitionQuery Eltávolított. 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ított. Mostantól alapértelmezés szerint engedélyezve van, és a diagnosztika része.
FeedOptions.RequestContinuation Eltávolított. A lekérdezési metódusok mostantól maguk is előléptetik.
FeedOptions.JsonSerializerSettings Eltávolított. További információkért tekintse meg, hogyan szabhatja testre a szerializálást .
FeedOptions.PartitionKeyRangeId Eltávolított. Ugyanez az eredmény érhető el a FeedRange lekérdezési módszer bemeneteként való használatával.
FeedOptions.DisableRUPerMinuteUsage Eltávolított.

Ügyfél létrehozása

A .NET SDK v3 egy olyan 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, hogy egyetlen Container objektum legyen átadva ahelyett, hogy egy DocumentClient, DatabaseNameés DocumentCollection.

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 a hibák jelzésére szolgál DocumentClientException , a v3 SDK CosmosExceptiona , amely elérhetővé teszi a StatusCode, Diagnosticsés egyéb válaszokkal kapcsolatos információkat. Az összes teljes információ szerializálva van a használat során 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 RequestDiagnosticsString csak közvetlen diagnosztika érhető el, a v3 SDK Diagnostics minden válaszban és kivételben elérhető, amely gazdagabb, és nem korlátozódik 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()
}

Csatlakozás ionPolicy

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

.NET v2 SDK .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - Az érték most invertált, ha EnableEndpointDiscovery az érték van beállítva true, LimitToEndpoint akkor a következőre kell állítani: false. A beállítás használata előtt tisztában kell lenni azzal, hogy ez hogyan érinti az ügyfelet.
ConnectionProtocol Eltávolított. A protokoll az átjáróhoz (HTTPS) vagy a directhez (TCP) van kötve. A HTTPS protokollt használó közvetlen mód már nem támogatott a V3 SDK-n, és a javaslat a TCP protokoll használata.
MediaRequestTimeout Eltávolított. 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ított. Az SDK automatikusan észleli, ha a fiók több írási végpontot is támogat.

Indexelési szabályzat

Az indexelési házirendben 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ák indexelését tekinti meg. A lekérdezési motor fejlesztései miatt ezeknek a tulajdonságoknak a konfigurálása, még ha régebbi SDK-verziót is használ, nincs hatással a teljesítményre.

Munkamenet-jogkivonat

Ha a v2 SDK közzétette a válasz munkamenet-jogkivonatát, mint ResourceResponse.SessionToken azokban az 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élyegző

Ha a v2 SDK közzétette egy dokumentum időbélyegét a Timestamp tulajdonságon keresztül, mivel Document az már nem érhető el, a felhasználók a _tsrendszertulajdonságot a modelljük egyik tulajdonságához rendelhetik.

OpenAsync

A v2 SDK-ügyfél CreateAndInitializeAsync bemelegítéséhez használt használati esetekben OpenAsync() v3 SDK-ügyfél létrehozása é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 processzor implementációjához. Korábban külön változáscsatorna-processzortá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

Hírcsatorna-lekérdezések módosítása

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ése érdekében a változáscsatorna FeedRanges használható. 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 jelképező FeedRange segítségével beolvasható az adott partíciókulcs-érték változáscsatornája.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - A változáscsatorna iterátora bármikor leálltatható és folytatható a folytatás mentésével és az új iterátor létrehozásakor való használatával.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - A változáscsatorna iterátora bármikor leálltatható és folytatható a folytatás mentésével és az új iterátor létrehozásakor való használatával.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - A változáscsatorna fogalmilag végtelen, így mindig több eredmény érhető el. 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 hívhatja ReadNextAsync , hogy tesztelje az új módosításokat.
Felosztás kezelése A változáscsatorna olvasása során a felhasználók már nem kötelesek felosztási kivételeket kezelni, a felosztások transzparens módon, 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 a 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 a tömeges végrehajtói kódtárból az Azure Cosmos DB .NET V3 SDK tömeges támogatására

Szerializálás testreszabása

A .NET V2 SDK lehetővé teszi a JsonSerializer Gépház 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áció műveleti szinten történő testreszabása Stream API-k használatával érhető el:

// .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 + Lejárati idő)

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ési mű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;
}

A tároló összes elemének beolvasá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);
        }
    }
}

Lekérdezési elemek

Az SqlQuerySpec módosítása (QueryDefinition in v3.0 SDK)

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áadódnak egy szerkesztőmodellhez a QueryDefinition használatával QueryDefinition.WithParameter. A felhasználók a paramétereket a következővel érhetik el: 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

  • Konzolalkalmazás létrehozása az Azure Cosmos DB for NoSQL-adatok kezeléséhez a v3 SDK használatával
  • További információ a v3 SDK-val elvégezhető műveletekről
  • Kapacitástervezést szeretne végezni az Azure Cosmos DB-be való migráláshoz?