Limitieren von Daten: die Take() & Skip() Methode

Bisher haben wir in diesem LINQ-Kapitel des Lernprogramms mehrere Möglichkeiten zum Arbeiten mit Datenquellen mithilfe von LINQ ermittelt. Jetzt ist es an der Zeit zu sehen, wie wir die Datenmenge begrenzen können. Dies ist besonders nützlich, wenn Sie eine Datenbank als Datenquelle verwenden, da sie oft sehr viele Zeilen enthält, deren Ressourcenverbrauch sehr hoch ist.

Die Methoden, die wir in diesem Artikel diskutieren werden, heißen Take() und Skip(). In Kombination eignen sie sich hervorragend für Seitenumbrüche auf einer Website. Tatsächlich werden sie oft zusammen verwendet, aber sie können natürlich auch alleine verwendet werden. Mit der Methode Take() erhalten Sie die X-Anzahl der Elemente aus der Datenquelle, während Sie mit Skip() die ersten X-Elemente ignorieren können. Ein einfaches Beispiel könnte so aussehen:

List<string> names = new List<string>()
{
    "John Doe",
    "Jane Doe",
    "Joe Doe",
    "Jenna Doe",
};
var middleNames = names.Skip(1).Take(2).ToList();
foreach (var name in middleNames)
    Console.WriteLine(name);

Wir erstellen eine einfache Liste von Namen und dann, für die Ausgabe, überspringen wir den ersten Namen (Skip(1)) und dann nehmen wir die nächsten zwei Namen (Take(2)), im Grunde nur mit den beiden zweiten Vornamen von Die Liste.

Einfache Seitennummerierung mit Skip() und Take()

Wie Sie sehen können, sind sowohl die Take() - als auch die Skip() -Methode sehr einfach zu verwenden, aber sie sind interessanter, um mehr Daten zu demonstrieren, als wir bisher verwendet haben. Daher habe ich mir die Freiheit genommen, ein etwas komplexeres Beispiel zu erstellen , die besser zeigen, wie diese Methoden Ihnen helfen können. Hier ist der Code dafür:

using System;
using System.Globalization;
using System.Linq;
using System.Xml.Linq;

namespace LinqTakeSkip1
{
    class Program
    {
    static void Main(string[] args)
    {
        CultureInfo usCulture = new CultureInfo("en-US");
        XDocument xDoc = XDocument.Load("http://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml");
        var cubeNodes = xDoc.Descendants().Where(n => n.Name.LocalName == "Cube" && n.Attribute("currency") != null).ToList();
        var currencyRateItems = cubeNodes.Select(node => new
        {
        Currency = node.Attribute("currency").Value,
        Rate = double.Parse(node.Attribute("rate").Value, usCulture)
        });


        int pageSize = 5, pageCounter = 0;
        var pageItems = currencyRateItems.Take(pageSize);
        while(pageItems.Count() > 0)
        {
        foreach (var item in pageItems)
            Console.WriteLine(item.Currency + ": " + item.Rate.ToString("N2", usCulture));
        Console.WriteLine("Press any key to get the next items...");
        Console.ReadKey();
        pageCounter++;
        // Here's where we use the Skip() and Take() methods!
        pageItems = currencyRateItems.Skip(pageSize * pageCounter).Take(pageSize);
        }
        Console.WriteLine("Done!");
        
    }
    }
}

Das ist ziemlich viel Code, aber lasst uns das durchgehen. In der ersten Hälfte analysieren wir eine öffentlich verfügbare XML -Quelle der Wechselkurse. Dies gibt mir die Möglichkeit, Ihnen kurz LINQ to XML zu zeigen, was ein sehr cooler Teil des LINQ-Ökosystems ist. Wir werden LINQ to XML in einem anderen Artikel diskutieren, aber jetzt wissen wir nur, dass wir damit die wichtigen Knoten aus der XML-Quelle herausziehen und in anonyme Objekte setzen, die aus dem Namen und dem aktuellen Wechselkurs der Währung bestehen die wir später verwenden werden.

Wir haben jetzt eine schöne Datenquelle für Währungsinformationen in der Variablen "währungsRatenElemente". In der letzten Hälfte des Beispiels verwenden wir diese Quelle für eine einfache Seitennummerierung - wir ziehen einfach 5 Einträge heraus und bitten den Benutzer, eine Taste zu drücken, um die nächsten 5 zu erhalten (oder wie viele noch in der Quelle übrig sind). Wir machen das, indem wir die ersten 5 Einträge extrahieren und dann verwenden wir eine while-Schleife, um die nächsten 5 Einträge kontinuierlich herauszuziehen, bis die Quelle leer ist. Die nächsten 5 Einträge werden mit einer Kombination aus Skip() und Take() erstellt - die gesamte Basis dieses Artikels.

Zusammenfassung

Die Methoden Skip() und Take() sind sehr einfach zu benutzen, aber in vielen Situationen sehr nützlich. Wie bereits erwähnt, werden sie häufig zusammen verwendet, aber insbesondere die Take() -Methode kann genauso gut alleine verwendet werden.