Migrasikan aplikasi Anda untuk menggunakan Microsoft Azure Cosmos DB .NET SDK v3

  • Artikel

BERLAKU UNTUK: NoSQL

Penting

Untuk mempelajari tentang Azure Cosmos DB .NET SDK v3, lihat Catatan rilis, Repositori .NET GitHub, Tips Kinerja .NET SDK v3, dan Panduan pemecahan masalah.

Artikel ini menyoroti beberapa pertimbangan meningkatkan aplikasi .NET Anda yang ada ke Azure Cosmos DB .NET SDK v3 yang lebih baru untuk API untuk NoSQL. Azure Cosmos DB .NET SDK v3 sesuai dengan namespace Microsoft.Azure.Azure Cosmos DB. Anda dapat menggunakan informasi yang disediakan dalam dokumen ini jika Anda memigrasikan aplikasi Anda dari salah satu Azure Cosmos DB .NET SDK berikut:

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

Instruksi dalam artikel ini juga membantu Anda memigrasikan pustaka eksternal berikut yang sekarang menjadi bagian dari Azure Cosmos DB .NET SDK v3 untuk API untuk NoSQL:

  • pustaka prosesor umpan perubahan .NET 2.0
  • pustaka pelaksana massal .NET 1.1 atau lebih tinggi

Apa yang baru di .NET V3 SDK

V3 SDK memuat banyak peningkatan kegunaan dan performa, termasuk:

  • Penamaan model pemrograman intuitif
  • .NET Standar 2.0 **
  • Peningkatan performa melalui dukungan API aliran
  • Hierarki fasih yang menggantikan kebutuhan akan pabrik URI
  • Dukungan bawaan untuk pustaka prosesor umpan perubahan
  • Dukungan bawaan untuk operasi massal
  • API Mockabale untuk pengujian unit yang lebih mudah
  • Batch transaksional dan dukungan Blazor
  • Serializer yang dapat dicolokkan
  • Kontainer skala non-partisi dan skala otomatis

** SDK menarget .NET Standard 2.0 yang menyatukan Azure Cosmos DB .NET Framework dan beberapa .NET Core SDK yang sudah ada ke dalam satu .NET SDK. Anda dapat menggunakan .NET SDK pada platform apa pun yang menerapkan .NET Standar 2.0, termasuk aplikasi .NET Framework 4.6.1+ dan .NET Core 2.0+ Anda.

Sebagian besar jaringan, mencoba kembali logika, dan tingkat yang lebih rendah dari SDK sebagian besar tetap tidak berubah.

Azure Cosmos DB .NET SDK v3 sekarang menjadi sumber terbuka. Kami menerima semua permintaan pull dan akan mencatat semua masalah dan melacak umpan balik diGitHub. Kami akan mengerjakan semua fitur yang akan meningkatkan pengalaman pelanggan.

Mengapa bermigrasi ke .NET v3 SDK

Selain banyaknya peningkatan kegunaan dan performa, investasi fitur baru yang diterapkan dalam SDK terbaru tidak akan di-porting kembali ke versi lama. SDK v2 saat ini dalam mode pemeliharaan. Untuk pengalaman pengembangan terbaik, kami menyarankan agar Anda selalu memulai dengan versi SDK terbaru yang didukung.

Perubahan nama utama dari v2 SDK ke v3 SDK

Perubahan nama berikut telah diterapkan di seluruh .NET 3.0 SDK untuk menyelaraskan dengan konvensi penamaan API untuk API untuk NoSQL:

  • DocumentClient berganti nama menjadi CosmosClient
  • Collection berganti nama menjadi Container
  • Document berganti nama menjadi Item

Semua objek sumber daya diganti namanya dengan properti tambahan, yang mencakup nama sumber daya untuk kejelasan.

Berikut ini adalah beberapa perubahan nama kelas yang utama:

.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

Beberapa kelas diganti pada .NET v3 SDK

Kelas-kelas berikut ini telah diganti pada SDK 3.0:

  • Microsoft.Azure.Documents.UriFactory

Kelas Microsoft.Azure.Documents.UriFactory telah digantikan dengan desain fasih.

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

Karena .NET v3 SDK memungkinkan pengguna untuk mengonfigurasi mesin serialisasi kustom, tidak ada penggantian langsung untuk jenis tersebut Document . Saat menggunakan Newtonsoft.Json (mesin serialisasi default), JObject dapat digunakan untuk mendapatkan fungsionalitas yang sama. Saat menggunakan mesin serialisasi yang berbeda, Anda dapat menggunakan jenis dokumen json dasarnya (misalnya, JsonDocument untuk System.Text.Json). Sebaiknya, gunakan tipe C# yang mencerminkan skema item Anda dibandingkan mengandalkan jenis generik.

  • Microsoft.Azure.Documents.Resource

Tidak ada penggantian langsung untuk Resource, dalam kasus di mana ia digunakan untuk dokumen, ikuti panduan untuk Document.

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatch atau IfMatch sekarang tersedia secara Microsoft.Azure.Cosmos.ItemRequestOptions langsung.

Perubahan atas pembuatan ID item

ID item tidak lagi diisi secara otomatis pada .NET v3 SDK. Oleh karena itu, ID item harus secara khusus menyertakan ID yang dihasilkan. Lihat contoh berikut ini:

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

Perilaku default yang diubah untuk mode koneksi

SDK v3 sekarang default ke mode koneksi Direct + TCP dibandingkan dengan SDK v2 sebelumnya, yang default ke mode koneksi Gateway + HTTPS. Perubahan ini memberikan peningkatan performa dan skalabilitas.

Perubahan pada FeedOptions (QueryRequestOptions pada v3.0 SDK)

Kelas FeedOptions di SDK v2 sekarang telah diubah namanya menjadi QueryRequestOptions di SDK v3, dan di dalam kelas ini, beberapa properti telah diubah nama dan/atau nilai default-nya, atau sepenuhnya dihapus.

.NET v2 SDK .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency - Nilai default dan perilaku terkait tetap sama, operasi menjalankan sisi klien selama eksekusi kueri paralel akan dijalankan secara serial tanpa paralelisme.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Perilaku dipertahankan.
FeedOptions.EnableCrossPartitionQuery Dihapus. Perilaku default dalam SDK 3.0 adalah bahwa kueri lintas partisi akan dijalankan tanpa perlu mengaktifkan properti secara khusus.
FeedOptions.PopulateQueryMetrics Dihapus. Sekarang diaktifkan secara default dan bagian dari diagnostik.
FeedOptions.RequestContinuation Dihapus. Sekarang dipromosikan ke metode kueri itu sendiri.
FeedOptions.JsonSerializerSettings Dihapus. Lihat cara menyesuaikan serialisasi untuk informasi tambahan.
FeedOptions.PartitionKeyRangeId Dihapus. Hasil yang sama dapat diperoleh dari menggunakan FeedRange sebagai input ke metode kueri.
FeedOptions.DisableRUPerMinuteUsage Dihapus.

Mengonstruksi klien

.NET SDK v3 menyediakan kelas CosmosClientBuilder fasih yang menggantikan kebutuhan akan SDK v2 URI Factory.

Desain fasih membangun URL secara internal dan memungkinkan satu objek Container untuk diedarkan alih-alih DocumentClient, DatabaseName, dan DocumentCollection.

Contoh berikut membuat CosmosClientBuilder yang baru dengan ConsistencyLevel yang kuat dan daftar lokasi pilihan:

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

Pengecualian

Meskipun SDK v2 menggunakan DocumentClientException untuk memberi sinyal kesalahan selama operasi, SDK v3 menggunakan CosmosException, yang mengekspos StatusCode, Diagnostics, dan informasi terkait respons lainnya. Semua informasi lengkap diserialkan saat ToString() digunakan:

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

Diagnostik

Meskipun SDK v2 memiliki Diagnostik langsung yang tersedia melalui properti RequestDiagnosticsString, SDK v3 menggunakan Diagnostics yang tersedia di semua tanggapan dan pengecualian, yang lebih kaya dan tidak terbatas pada mode Langsung. Mereka tidak hanya mencakup waktu yang dihabiskan pada SDK untuk operasi, tetapi juga wilayah yang dihubungi operasi:

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

Beberapa pengaturan di ConnectionPolicy telah diganti namanya atau diganti dengan CosmosClientOptions:

.NET v2 SDK .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - Nilainya sekarang terbalik, jika EnableEndpointDiscovery sedang diatur ke true, LimitToEndpointharus diatur ke false. Sebelum menggunakan pengaturan ini, Anda perlu memahami bagaimana hal itu mempengaruhi klien.
ConnectionProtocol Dihapus. Protokol terkait dengan Mode, baik itu Gateway (HTTPS) atau Direct (TCP). Mode langsung dengan protokol HTTPS tidak lagi didukung di V3 SDK dan rekomendasinya adalah menggunakan protokol TCP.
MediaRequestTimeout Dihapus. Lampiran tidak lagi didukung.
SetCurrentLocation CosmosClientOptions.ApplicationRegion dapat digunakan untuk mencapai efek yang sama.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions dapat digunakan untuk mencapai efek yang sama.
UserAgentSuffix CosmosClientBuilder.ApplicationName dapat digunakan untuk mencapai efek yang sama.
UseMultipleWriteLocations Dihapus. SDK secara otomatis mendeteksi apakah akun mendukung beberapa titik akhir tulis.

Kebijakan pengindeksan

Dalam kebijakan pengindeksan, tidak mungkin untuk mengonfigurasi properti ini. Jika tidak ditentukan, properti ini sekarang akan selalu memiliki nilai berikut:

Nama Properti Nilai Baru (tidak dapat dikonfigurasi)
Kind range
dataType String dan Number

Lihat bagian ini untuk contoh kebijakan pengindeksan untuk menyertakan dan mengecualikan jalur. Karena peningkatan pada mesin kueri, mengonfigurasi properti ini, meskipun menggunakan versi SDK yang lebih lama, tidak akan berdampak pada performa.

Token sesi

Meskipun SDK v2 mengekspos token sesi suatu respons sebagai ResourceResponse.SessionToken untuk kasus ketika menangkap token sesi diperlukan, karena token sesi adalah header, SDK v3 mengekspos nilai itu dalam properti Headers.Session dari respons apa pun.

Tanda Waktu

Meskipun SDK v2 mengekspos tanda waktu suatu dokumen melalui properti Timestamp, karena Document tidak lagi tersedia, pengguna dapat memetakan _tsproperti sistem ke properti dalam modelnya.

OpenAsync

Untuk kasus penggunaan apabila OpenAsync() digunakan untuk menghangatkan klien SDK v2, CreateAndInitializeAsync dapat digunakan untuk membuat dan menghangatkan klien SDK v3.

Menggunakan API prosesor umpan perubahan secara langsung dari v3 SDK

V3 SDK memiliki dukungan bawaan untuk API Prosesor Umpan Perubahan, memungkinkan Anda menggunakan SDK yang sama untuk membangun aplikasi Anda dan implementasi prosesor umpan perubahan. Sebelumnya, Anda harus menggunakan pustaka prosesor umpan perubahan yang terpisah.

Untuk informasi selengkapnya, lihat cara migrasi dari pustaka prosesor umpan perubahan ke Azure Cosmos DB .NET v3 SDK

Kueri umpan perubahan

Menjalankan kueri umpan perubahan pada v3 SDK dianggap menggunakan model penarikan umpan perubahan. Ikuti tabel ini untuk memigrasikan konfigurasi:

.NET v2 SDK .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange - Untuk mencapai paralelisme membaca perubahan feedRanges dapat digunakan. Ini bukan lagi parameter yang diperlukan, Anda dapat membaca Umpan Perubahan untuk seluruh kontainer dengan mudah sekarang.
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey - FeedRange yang mewakili Kunci Partisi yang diinginkan dapat digunakan untuk membaca Umpan Perubahan untuk nilai Kunci Partisi tersebut.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - Iterator umpan perubahan dapat dihentikan dan dilanjutkan kapan saja dengan menyimpan kelanjutan dan menggunakannya saat membuat iterator baru.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - Iterator umpan perubahan dapat dihentikan dan dilanjutkan kapan saja dengan menyimpan kelanjutan dan menggunakannya saat membuat iterator baru.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - Umpan perubahan secara konseptual tidak terbatas, sehingga selalu ada lebih banyak hasil. Ketika respons berisi HttpStatusCode.NotModified kode status, itu berarti tidak ada perubahan baru untuk dibaca saat ini. Anda dapat menggunakannya untuk menghentikan dan menyimpan kelanjutan atau untuk tidur sementara atau menunggu lalu memanggil ReadNextAsync lagi untuk menguji perubahan baru.
Penanganan terpisah Pengguna tidak lagi diharuskan untuk menangani pengecualian terpisah saat membaca umpan perubahan, pemisahan akan ditangani secara transparan tanpa perlu interaksi pengguna.

Menggunakan pustaka pelaksana massal secara langsung dari V3 SDK

V3 SDK memiliki dukungan bawaan untuk pustaka pelaksana massal, sehingga memungkinkan Anda menggunakan SDK yang sama untuk membangun aplikasi Anda dan melakukan operasi massal. Sebelumnya, Anda diharuskan menggunakan pustaka pelaksana massal yang terpisah.

Untuk informasi selengkapnya, lihat cara migrasi dari pustaka pelaksana massal ke dukungan massal di Azure Cosmos DB .NET V3 SDK

Menyesuaikan serialisasi

.NET V2 SDK memungkinkan pengaturan JsonSerializer Pengaturan di RequestOptions pada tingkat operasional yang digunakan untuk mendeserialisasi dokumen hasil:

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

.NET SDK v3 menyediakan antarmuka serializer untuk sepenuhnya menyesuaikan mesin serialisasi, atau opsi serialisasi yang lebih umum sebagai bagian dari konstruksi klien.

Menyesuaikan serialisasi di tingkat operasi dapat dicapai melalui penggunaan API Stream:

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

Perbandingan cuplikan kode

Cuplikan kode berikut ini menunjukkan perbedaan seputar cara sumber daya dibuat antara .NET v2 SDK dan .NET v3 SDK:

Operasi database

Membuat database

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

Baca database menurut 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()}");
        }
    }
}

Menghapus database

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

Operasi kontainer

Buat kontainer (Skala Otomatis + Jangka hidup dengan kedaluwarsa)

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

Baca properti kontainer

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

Menghapus kontainer

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

Operasi item dan kueri

Membuat item

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

Baca semua item dalam kontainer

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

Buat kueri item

Perubahan pada SqlQuerySpec (QueryDefinition di v3.0 SDK)

Kelas SqlQuerySpec di SDK v2 kini telah diganti namanya menjadi QueryDefinition di SDK v3.

SqlParameterCollection dan SqlParameter telah dihapus. Parameter sekarang ditambahkan ke QueryDefinition dengan model penyusun menggunakan QueryDefinition.WithParameter. Pengguna dapat mengakses parameter dengan 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);
        }
    }
}

Menghapus item

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

Mengubah kueri umpan

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

Langkah berikutnya