Übung: Aufzählen von Elementen mit LINQ (Language Integrated Query)

7 Minuten

Obwohl die Anwendung bereits alle Anforderungen erfüllt, gibt es noch eine weitere Änderung, die vorgenommen werden kann. C#-Entwickler verwenden die LINQ-Syntax, um Abfragen an Sammlungen von Daten auszuführen. Das .NET SDK für Azure Cosmos DB for NoSQL verfügt über einen integrierten Mechanismus zum Erstellen Ihrer Abfrage mithilfe der LINQ-Methodensyntax.

Derzeit gibt es zwei wichtige Anforderungen:

Erstellen einer neuen Abfrage mithilfe der LINQ-Syntax
Konvertieren der Abfrage in einen Feediterator zum Abrufen von Ergebnissen

Illustration of icons indicating data being queried using a LINQ expression.

Nachdem Sie diese Übung abgeschlossen haben, verwenden Ihre Abfragen nun die LINQ-Syntax, um Entwicklern die Verwaltung Ihrer Anwendung im weiteren Prozess zu erleichtern.

Abfragen mit LINQ-Ausdrücken

Ihr Team benötigt eine eindeutige Abfrage, die alle Produkte im Container, unabhängig von der Kategorie, zurückgibt. Erinnern Sie sich daran, dass wir die type-Eigenschaft verwendet haben, um unsere Kategorieelemente von den einzelnen Produktelementen zu trennen. Hier erstellen wir eine partitionsübergreifende Abfrage mithilfe der LINQ-Methodensyntax.

Tipp

Da wir mehrere Kategorien abfragen, wird unsere Abfrage dadurch partitionsübergreifend. Diese Abfrage könnte potenziell mehr RUs als eine Abfrage verwenden, die auf einen einzelnen logischen Partitionsschlüsselwert begrenzt ist.

Öffnen Sie die Datei Program.cs ein letztes Mal.

Erstellen Sie mithilfe der GetItemLinqQueryable-Methode eine neue LINQ-Abfrage.

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

Erstellen Sie einen LINQ-Ausdruck mithilfe der Where- und OrderBy-Methoden, und speichern Sie den Ausdruck in einer neuen Variablen.
```
var matches = queryable
    .Where(p => p.Type == nameof(Product))
    .Where(p => !p.Archived)
    .OrderBy(p => p.Price);
```
Verwenden Sie die Methode IOrderedQueryable<>.ToFeedIterator, um einen Feediterator aus dem LINQ-Ausdruck abzurufen.
```
using FeedIterator<Product> linqFeed = matches.ToFeedIterator();
```
Geben Sie eine Nachricht in die Konsole aus.
```
Console.WriteLine($"[Start LINQ query]");
```
Speichern Sie die Datei Program.cs.

Paginieren von LINQ-Abfrageergebnissen

Da wir mehrere logische Partitionen abfragen, müssen wir sicherstellen, dass alle Ergebnisse zurückgegeben werden, auch wenn eine logische Partition keine übereinstimmenden Ergebnisse enthält. Beispielsweise verfügt die Kategorie helmets (Helme) über keine passenden Produkte. Wenn wir nicht alle möglichen Seiten zurückgeben würden, könnte unsere Anwendung versehentlich anhalten, wenn sie eine leere Seite mit Ergebnissen für die Kategorie Helme sieht. Hier verwenden Sie erneut eine while- und foreach-Schleife in C#, um alle Ergebnisseiten zu durchlaufen. Der Code sollte dem ähneln, wie Sie zuvor schon einen Feediterator verwendet haben.

Erstellen Sie in Program.cs eine while-Schleife, die durchlaufen wird, bis der Feediterator keine weiteren Seiten mehr enthält.
```
while (linqFeed.HasMoreResults)
{    
}
```
Innerhalb der while-Schleife rufen Sie eine neue Seite mit Ergebnissen ab.
```
FeedResponse<Product> page = await linqFeed.ReadNextAsync();
```
Geben Sie weiterhin innerhalb der while-Schleife die Anforderungsbelastung der aktuellen Seite aus.
```
Console.WriteLine($"[Page RU charge]:\t{page.RequestCharge}");
```
Erstellen Sie weiterhin innerhalb der while-Schleife eine neue foreach-Schleife, um die Elemente der Seite zu durchlaufen.
```
foreach (Product item in page)
{
}
```
Schreiben Sie innerhalb der foreach-Schleife die einzelnen Elemente in die Konsole.
```
Console.WriteLine($"[Returned item]:\t{item}");
```
Speichern Sie die Datei Program.cs.

Arbeit überprüfen

Ihre App verwendet jetzt LINQ, um eine partitionsübergreifende Abfrage zu erstellen, die Ihr Entwicklerteam nativ versteht. Hier führen Sie die Anwendung ein letztes Mal aus, um sicherzustellen, dass alle Abfragen die erwarteten Ergebnisse zurückgeben.

Ausführen der Anwendung
Überprüfen des Codes

Ausführen der .NET-Anwendung im Terminal:
```
dotnet run
```

Beobachten Sie die Ausgabe der Ausführung der Anwendung. Die Ausgabe sollte dem folgenden Beispiel entsprechen:

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

Tipp

Die in dieser Beispielausgabe gezeigten RUs können von Ihrer Ausgabe abweichen.

Überprüfen Sie die Codedatei Program.cs, um sicherzustellen, dass Ihr Code diesem Beispiel entspricht.

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

Weiter

Abfragen mit LINQ-Ausdrücken

Paginieren von LINQ-Abfrageergebnissen

Arbeit überprüfen

Feedback