Esercizio - Enumerare gli elementi usando LINQ (Language Integrated Query)

Completato

Anche se l'applicazione soddisfa già tutti i requisiti, c'è un'altra modifica che si apporta. Gli sviluppatori C# usano la sintassi LINQ (Language Integrated Query) per eseguire query su raccolte di dati. .NET SDK per NoSQL di Azure Cosmos DB include un meccanismo predefinito per creare la query usando la sintassi dei metodi LINQ.

In questo caso ci sono due requisiti chiave:

1. Creare una nuova query usando la sintassi LINQ
2. Convertire la query in un iteratore di feed per ottenere i risultati

Dopo aver completato l'esercizio, le query useranno la sintassi LINQ per semplificare la gestione dell'applicazione da parte degli sviluppatori.

Eseguire query usando espressioni LINQ

Il team vuole disporre di una query univoca che restituisca tutti gli oggetti Product nel contenitore indipendentemente dalla categoria. Ricordare che è stata usata la proprietà type per separare gli elementi Category dai singoli elementi Product. Si creerà ora una query su più partizioni usando la sintassi dei metodi LINQ.

Suggerimento

Poiché si esegue la query su più categorie, la query si estende in più partizioni. Questa query potrebbe usare più unità richiesta (UR) rispetto a una query con ambito impostato su un singolo valore di chiave di partizione logica.

1. Apri il file Program.cs un'ultima volta.

2. Creare un nuovo tipo queryable LINQ usando il metodo GetItemLinqQueryable.

   IOrderedQueryable<Product> queryable = container.GetItemLinqQueryable<Product>();
   

3. Creare un'espressione LINQ usando i metodi Where e OrderBy e archiviare l'espressione in una nuova variabile.

   var matches = queryable
       .Where(p => p.Type == nameof(Product))
       .Where(p => !p.Archived)
       .OrderBy(p => p.Price);
   

4. Usare il metodo IOrderedQueryable<>.ToFeedIterator per ottenere un iteratore di feed dall'espressione LINQ.

   using FeedIterator<Product> linqFeed = matches.ToFeedIterator();
   

5. Restituire come output un messaggio nella console.

   Console.WriteLine($"[Start LINQ query]");
   

6. Salvare il file Program.cs.

Impaginare i risultati delle query LINQ

Poiché le query vengono eseguite su più partizioni logiche, è necessario assicurarsi di restituire tutti i risultati anche se una partizione logica non ha risultati corrispondenti. La categoria helmets, ad esempio, non ha prodotti corrispondenti. Se non venissero restituite tutte le pagine possibili, l'applicazione potrebbe interrompersi inavvertitamente quando trova una pagina vuota di risultati per la categoria helmets. Si usano di nuovo i cicli while e foreach in C# per eseguire l'iterazione di tutte le pagine dei risultati. Il codice sarà simile a quello per l'iteratore di feed precedente.

1. In Program.cs crea un ciclo while che eseguirà l'iterazione fino a quando l'iteratore di feed non ha più pagine.

   while (linqFeed.HasMoreResults)
   {    
   }
   

2. Nel ciclo while ottenere una nuova pagina di risultati.

   FeedResponse<Product> page = await linqFeed.ReadNextAsync();
   

3. All'interno del ciclo while restituire come output l'addebito della richiesta per la pagina corrente.

   Console.WriteLine($"[Page RU charge]:\t{page.RequestCharge}");
   

4. All'interno del ciclo while creare un nuovo ciclo foreach per eseguire l'iterazione degli elementi della pagina.

   foreach (Product item in page)
   {
   }
   

5. Nel ciclo foreach scrivere i singoli elementi nella console.

   Console.WriteLine($"[Returned item]:\t{item}");
   

6. Salvare il file Program.cs.

Controlla il tuo lavoro

L'app ora usa LINQ per creare una query su più partizioni che il team di sviluppo comprende in modo nativo. Si esegue ora l'applicazione un'ultima volta per assicurarsi che tutte le query restituiscano i risultati previsti.

Esegui l'applicazione

1. Eseguire l'applicazione .NET nel terminale:

   dotnet run
   

2. Osservare l'output dell'esecuzione dell'applicazione. L'output dovrebbe essere simile all'esempio seguente:

   [Start LINQ query]
   [Page RU charge]:       3
   [Returned item]:        Product { Id = 6e3b7275-57d4-4418-914d-14d1baca0979, CategoryId = gear-camp-tents, Type = Product, Name = Nimbolo Tent, Price = 330, Archived = False, Quantity = 35 }
   [Returned item]:        Product { Id = e8dddee4-9f43-4d15-9b08-0d7f36adcac8, CategoryId = gear-camp-tents, Type = Product, Name = Cirroa Tent, Price = 490, Archived = False, Quantity = 15 }
   [Returned item]:        Product { Id = e6f87b8d-8cd7-4ade-a005-14d3e2fbd1aa, CategoryId = gear-camp-tents, Type = Product, Name = Kuloar Tent, Price = 530, Archived = False, Quantity = 8 }
   

   Suggerimento

   Le unità richiesta (UR) mostrate nell'output di esempio possono variare rispetto all'output ottenuto.

Esaminare il codice

1. Esaminare il file di codice Program.cs per assicurarsi che il codice corrisponda a questo esempio.

   using Azure.Identity;
   using Microsoft.Azure.Cosmos;
   using Microsoft.Azure.Cosmos.Fluent;
   using Microsoft.Azure.Cosmos.Linq;
   
   // Code to create client omitted for brevity
   
   // Code to create resources omitted for brevity
   
   // Code to create items omitted for brevity
   
   // Code to query items omitted for brevity
   
   IOrderedQueryable<Product> queryable = container.GetItemLinqQueryable<Product>();
   
   var matches = queryable
       .Where(p => p.Type == nameof(Product))
       .Where(p => !p.Archived)
       .OrderBy(p => p.Price);
   
   using FeedIterator<Product> linqFeed = matches.ToFeedIterator();
   
   Console.WriteLine($"[Start LINQ query]");
   
   while (linqFeed.HasMoreResults)
   {
       FeedResponse<Product> page = await linqFeed.ReadNextAsync();
       Console.WriteLine($"[Page RU charge]:\t{page.RequestCharge}");
       foreach (Product item in page)
       {
           Console.WriteLine($"[Returned item]:\t{item}");
       }
   }