Condividi tramite

Eseguire la migrazione dell'applicazione per usare Azure Cosmos DB .NET SDK v3

  • Si applica a: ✅ NoSQL

Importante

Per informazioni su Azure Cosmos DB .NET SDK v3, vedere le note sulla versione, il repository GitHub .NET, i suggerimenti sulle prestazioni di .NET SDK v3 e la guida alla risoluzione dei problemi.

Questo articolo illustra alcune considerazioni sull'aggiornamento dell'applicazione .NET esistente alla versione più recente di Azure Cosmos DB .NET SDK v3 per l'API per NoSQL. Azure Cosmos DB .NET SDK v3 corrisponde allo spazio dei nomi Microsoft.Azure.Azure Cosmos DB. È possibile usare le informazioni fornite in questo documento se si esegue la migrazione dell'applicazione da uno degli SDK .NET di Azure Cosmos DB seguenti:

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

Le istruzioni in questo articolo consentono anche di eseguire la migrazione delle librerie esterne seguenti che fanno ora parte di Azure Cosmos DB .NET SDK v3 per API per NoSQL:

  • Libreria per l'elaborazione delle modifiche nei feed .NET 2.0
  • Libreria .NET Bulk Executor 1.1 o versione successiva

Novità di .NET V3 SDK

L'SDK v3 contiene numerosi miglioramenti dell'usabilità e delle prestazioni, tra cui:

  • Denominazione intuitiva del modello di programmazione
  • .NET Standard 2.0 **
  • Miglioramento delle prestazioni tramite il supporto dell'API di flusso
  • Gerarchia fluente che sostituisce la necessità di fabbrica URI
  • Supporto integrato per la libreria del Change Feed Processor
  • Supporto predefinito per le operazioni in blocco
  • API fittizie per un test unità più semplice
  • Supporto per batch transazionale e Blazor
  • Serializzatori collegabili
  • Scalare i contenitori non partizionati e quelli con scalabilità automatica

L'SDK è destinato a .NET Standard 2.0 e unifica gli SDK esistenti di .NET Framework e .NET Core in un unico SDK .NET. È possibile usare .NET SDK in qualsiasi piattaforma che implementa .NET Standard 2.0, incluse le applicazioni .NET Framework 4.6.1+ e .NET Core 2.0+.

La maggior parte delle reti, la logica di ripetizione dei tentativi e i livelli inferiori dell'SDK rimangono in gran parte invariati.

Azure Cosmos DB .NET SDK v3 è ora open source. Siamo disponibili ad accettare qualsiasi richiesta pull e registreremo i problemi e monitoreremo i feedback su GitHub. Lavoreremo su tutte le funzionalità che miglioreranno l'esperienza dei clienti.

Perché eseguire la migrazione a .NET v3 SDK

Oltre ai numerosi miglioramenti per l'usabilità e le prestazioni, i nuovi investimenti di funzionalità effettuati nell'SDK più recente non verranno trasferiti alle versioni precedenti. L'SDK v2 è attualmente in modalità di manutenzione. Per un'esperienza di sviluppo ottimale, è consigliabile iniziare sempre con la versione più recente supportata di SDK.

Modifiche principali del nome da SDK v2 a v3 SDK

Le modifiche al nome seguenti sono state applicate in .NET 3.0 SDK per allinearsi alle convenzioni di denominazione api per l'API per NoSQL:

  • DocumentClient viene rinominato in CosmosClient
  • Collection viene rinominato in Container
  • Document viene rinominato in Item

Tutti gli oggetti risorsa vengono rinominati con proprietà aggiuntive, che includono il nome della risorsa per maggiore chiarezza.

Di seguito sono riportate alcune delle modifiche apportate al nome della classe principale:

.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

Classi sostituite in .NET v3 SDK

Le classi seguenti sono state sostituite nell'SDK 3.0:

  • Microsoft.Azure.Documents.UriFactory

La classe Microsoft.Azure.Documents.UriFactory è stata sostituita dalla progettazione Fluent.

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

Poiché .NET v3 SDK consente agli utenti di configurare un motore di serializzazione personalizzato, non esiste alcuna sostituzione diretta per il Document tipo. Quando si usa Newtonsoft.Json (motore di serializzazione predefinito), JObject è possibile usare per ottenere la stessa funzionalità. Quando si usa un motore di serializzazione diverso, è possibile usare il tipo di documento JSON di base, JsonDocument ad esempio per System.Text.Json. È consigliabile usare un tipo C# che riflette lo schema degli elementi anziché basarsi su tipi generici.

  • Microsoft.Azure.Documents.Resource

Non esiste alcuna sostituzione diretta per Resource, nei casi in cui è stata usata per i documenti, seguire le indicazioni per Document.

  • Microsoft.Azure.Documents.AccessCondition

IfNoneMatch o IfMatch sono ora disponibili direttamente in Microsoft.Azure.Cosmos.ItemRequestOptions .

Modifiche alla generazione di ID elemento

L'ID elemento non viene più popolato automaticamente in .NET v3 SDK. Pertanto, l'ID elemento deve includere in modo specifico un ID generato. Visualizzare l'esempio seguente:

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

Modifica del comportamento predefinito per la modalità di connessione

L'SDK v3 ora usa le modalità di connessione Direct + TCP rispetto all'SDK v2 precedente, che per impostazione predefinita è gateway e modalità connessioni HTTPS. Questa modifica offre prestazioni e scalabilità migliorate.

Modifiche a FeedOptions (QueryRequestOptions nel SDK v3.0)

La FeedOptions classe in SDK v2 è ora stata rinominata QueryRequestOptions in nell'SDK v3 e all'interno della classe, diverse proprietà hanno subito modifiche al nome e/o al valore predefinito o sono state rimosse completamente.

.NET v2 SDK .NET v3 SDK
FeedOptions.MaxDegreeOfParallelism QueryRequestOptions.MaxConcurrency - Il valore predefinito e il comportamento associato rimangono invariati, le operazioni eseguite sul lato client durante l'esecuzione di query parallele verranno eseguite in modo seriale senza parallelismo.
FeedOptions.PartitionKey QueryRequestOptions.PartitionKey - Comportamento preservato.
FeedOptions.EnableCrossPartitionQuery Rimosso. Il comportamento predefinito in SDK 3.0 è che le query tra partizioni verranno eseguite senza la necessità di abilitare specificamente la proprietà.
FeedOptions.PopulateQueryMetrics Rimosso. Ora è abilitata per impostazione predefinita e parte della diagnostica.
FeedOptions.RequestContinuation Rimosso. Viene ora alzato di livello ai metodi di query stessi.
FeedOptions.JsonSerializerSettings Rimosso. Per altre informazioni, vedere come personalizzare la serializzazione .
FeedOptions.PartitionKeyRangeId Rimosso. Lo stesso risultato può essere ottenuto usando FeedRange come input per il metodo di query.
FeedOptions.DisableRUPerMinuteUsage Rimosso.

Creazione di un client

.NET SDK v3 offre una classe Fluent CosmosClientBuilder che sostituisce la necessità di SDK v2 URI Factory.

La progettazione Fluent costruisce gli URL internamente e permette di passare un singolo oggetto Container anziché oggetti DocumentClient, DatabaseName e DocumentCollection.

Nell'esempio seguente viene creato un nuovo CosmosClientBuilder oggetto con un elemento ConsistencyLevel sicuro e un elenco di posizioni preferite:

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

Exceptions

Dove l'SDK v2 utilizzava DocumentClientException per segnalare errori durante le operazioni, l'SDK v3 utilizza CosmosException, che espone le StatusCode, Diagnostics e altre informazioni correlate alla risposta. Tutte le informazioni complete vengono serializzate quando ToString() viene usato:

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

Diagnostics

Se l'SDK v2 aveva la diagnostica solo Direct disponibile tramite la proprietà RequestDiagnosticsString, l'SDK v3 utilizza Diagnostics disponibili in tutte le risposte ed eccezioni, che sono più complete e non limitate alla modalità Direct. Includono non solo il tempo dedicato all'SDK per l'operazione, ma anche le aree in cui è stata contattata l'operazione:

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

Politica di Connessione

Alcune impostazioni in ConnectionPolicy sono state rinominate o sostituite da CosmosClientOptions:

.NET v2 SDK .NET v3 SDK
EnableEndpointDiscovery LimitToEndpoint - Il valore è ora invertito, se EnableEndpointDiscovery è stato impostato su true, LimitToEndpoint deve essere impostato su false. Prima di usare questa impostazione, è necessario comprendere come influisce sul client.
ConnectionProtocol Rimosso. Il protocollo è associato alla modalità, ovvero Gateway (HTTPS) o Direct (TCP). La modalità diretta con il protocollo HTTPS non è più supportata in V3 SDK e si consiglia di usare il protocollo TCP.
MediaRequestTimeout Rimosso. Gli allegati non sono più supportati.
SetCurrentLocation CosmosClientOptions.ApplicationRegion può essere usato per ottenere lo stesso effetto.
PreferredLocations CosmosClientOptions.ApplicationPreferredRegions può essere usato per ottenere lo stesso effetto.
UserAgentSuffix CosmosClientBuilder.ApplicationName può essere usato per ottenere lo stesso effetto.
UseMultipleWriteLocations Rimosso. L'SDK rileva automaticamente se l'account supporta più endpoint di scrittura.

Politica di indicizzazione

Nei criteri di indicizzazione non è possibile configurare queste proprietà. Se non specificato, queste proprietà avranno sempre i valori seguenti:

Nome della proprietà Nuovo valore (non configurabile)
Kind range
dataType String e Number

Vedere questa sezione per consultare esempi di criteri di indicizzazione per includere ed escludere i percorsi. A causa di miglioramenti nel motore di query, la configurazione di queste proprietà, anche se si usa una versione precedente dell'SDK, non ha alcun impatto sulle prestazioni.

Token di sessione

Se l'SDK v2 ha esposto il token di sessione di una risposta come ResourceResponse.SessionToken nei casi in cui è necessario acquisire il token di sessione, perché il token di sessione è un'intestazione, l'SDK v3 espone tale valore nella Headers.Session proprietà di qualsiasi risposta.

Marca temporale:

Se l'SDK v2 ha esposto il timestamp di un documento tramite la Timestamp proprietà , poiché Document non è più disponibile, gli utenti possono eseguire il mapping della _tsproprietà di sistema a una proprietà nel modello.

Openasync

Per i casi d'uso in cui OpenAsync() è stato usato per riscaldare il client SDK v2, CreateAndInitializeAsync è possibile usare per creare e scaldare un client SDK v3.

Uso delle API del processore del flusso di modifiche direttamente dall'SDK v3

L'SDK v3 include il supporto predefinito per le API del processore del feed delle modifiche, consentendo di usare lo stesso SDK per lo sviluppo dell'applicazione e l'implementazione del processore del feed delle modifiche. In precedenza era necessario usare una libreria separata del processore dei feed di modifiche.

Per ulteriori informazioni, consultare come migrare dalla libreria del processore del change feed all'SDK di Azure Cosmos DB .NET v3

Query del feed di modifiche

L'esecuzione di query sui feed di modifiche nell'SDK v3 è considerato un utilizzo del modello pull del feed di modifiche. Seguire questa tabella per eseguire la migrazione della configurazione:

.NET v2 SDK .NET v3 SDK
ChangeFeedOptions.PartitionKeyRangeId FeedRange - Per ottenere il parallelismo, è possibile utilizzare i FeedRanges del change feed. Non è più un parametro obbligatorio, è possibile leggere facilmente il feed di modifiche per un intero contenitore .
ChangeFeedOptions.PartitionKey FeedRange.FromPartitionKey - FeedRange che rappresenta la chiave di partizione desiderata può essere usata per leggere il feed di modifiche per tale valore della chiave di partizione.
ChangeFeedOptions.RequestContinuation ChangeFeedStartFrom.Continuation - L'iteratore del feed di modifiche può essere arrestato e ripreso in qualsiasi momento salvando la continuazione e usandolo durante la creazione di un nuovo iteratore.
ChangeFeedOptions.StartTime ChangeFeedStartFrom.Time
ChangeFeedOptions.StartFromBeginning ChangeFeedStartFrom.Beginning
ChangeFeedOptions.MaxItemCount ChangeFeedRequestOptions.PageSizeHint - L'iteratore del feed di modifiche può essere arrestato e ripreso in qualsiasi momento salvando la continuazione e usandolo durante la creazione di un nuovo iteratore.
IDocumentQuery.HasMoreResults response.StatusCode == HttpStatusCode.NotModified - Il feed di modifiche è concettualmente infinito, quindi potrebbero esserci sempre più risultati. Quando una risposta contiene il HttpStatusCode.NotModified codice di stato, significa che al momento non sono presenti nuove modifiche da leggere. È possibile usarlo per arrestare e salvare la continuazione o per sospendere temporaneamente o attendere e quindi chiamare ReadNextAsync di nuovo per testare le nuove modifiche.
Suddivisione della gestione Non è più necessario per gli utenti gestire le eccezioni suddivise durante la lettura del feed di modifiche, le divisioni verranno gestite in modo trasparente senza la necessità di interazione dell'utente.

Uso della libreria bulk executor direttamente dall'SDK V3

Il SDK v3 include il supporto predefinito per la libreria dell'esecutore bulk, che consente di usare lo stesso SDK per lo sviluppo dell'applicazione e l'esecuzione di operazioni bulk. In precedenza era necessario usare una libreria di executor bulk separata.

Per ulteriori informazioni, vedere come eseguire la migrazione dalla libreria bulk executor al supporto per le operazioni bulk in Azure Cosmos DB .NET V3 SDK

Personalizzare la serializzazione

.NET V2 SDK consente di impostare JsonSerializerSettings in RequestOptions a livello operativo usato per deserializzare il documento del risultato:

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

.NET SDK v3 fornisce un'interfaccia di serializzazione per personalizzare completamente il motore di serializzazione, o opzioni di serializzazione più generiche come parte della costruzione del client.

La personalizzazione della serializzazione a livello di operazione può essere ottenuta tramite l'uso delle 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
        }
    }
}

Confronti tra frammenti di codice

Il frammento di codice seguente mostra le differenze nella modalità di creazione delle risorse tra gli SDK .NET v2 e v3:

Operazioni di database

Creazione di un 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));

Leggere un database per 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()}");
        }
    }
}

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

Operazioni del contenitore

Creare un contenitore (scalabilità automatica + tempo di vita con scadenza)

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

Leggere le proprietà del contenitore

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

Eliminare un contenitore

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

Operazioni sugli elementi e le query

Creare un elemento

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

Leggere tutti gli elementi in un contenitore

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

Elementi della query

Modifiche a SqlQuerySpec (QueryDefinition in v3.0 SDK)

La SqlQuerySpec classe in SDK v2 è stata rinominata QueryDefinition in nell'SDK v3.

SqlParameterCollection ed SqlParameter è stato rimosso. I parametri vengono ora aggiunti a QueryDefinition con un modello di generatore usando QueryDefinition.WithParameter. Gli utenti possono accedere ai parametri con 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);
        }
    }
}

Eliminare un elemento

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

Query del feed di modifiche

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

Passaggi successivi

  • Last updated on