TOC

This article has been localized into German by the community.

LINQ:

Filterung von Daten: die "Where()" Methode

Eine der grundlegendsten (aber auch leistungsstärksten) Operationen, die Sie an einer Datenmenge durchführen können, besteht darin, etwas davon herauszufiltern. Wir haben bereits einen kleinen Einblick in die Where() -Methode im LINQ-Einführungsartikel erhalten, aber in diesem Artikel werden wir etwas genauer hinschauen. Wir haben bereits besprochen, wie viele LINQ-Methoden einen Lambda-Ausdruck zur Ausführung ihrer Aufgabe verwenden können, und die Where() -Methode ist eine davon - sie liefert jedes Element als Eingabe und liefert dann die Logik, die darüber entscheidet, ob das Element vorhanden ist oder nicht enthalten (return true) oder ausgeschlossen (return false) vom Endergebnis. Hier ist ein einfaches Beispiel:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

In diesem Beispiel wird jede Zahl mit unserem Ausdruck verglichen, der wahr zurückgibt, wenn die Zahl kleiner als 10 ist und falsch, wenn er 10 oder höher ist. Als Ergebnis erhalten wir eine Version der ursprünglichen Liste, in der wir nur Zahlen unter 10 enthalten haben, die dann an die Konsole ausgegeben werden.

Aber der Ausdruck muss nicht so einfach sein - wir können leicht mehr Anforderungen hinzufügen, als wäre es eine regelmäßige if-Anweisung:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n > 1 && n != 4 &&  n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

Wir geben an, dass die Nummer größer als 1 sein muss, aber nicht die spezifische Nummer 4 und kleiner als 10.

Sie können natürlich auch verschiedene Methoden verwenden, um Ihren Ausdruck aufzurufen - solange das Endergebnis ein boolescher Wert ist, damit die Where() -Methode weiß, ob das betreffende Element enthalten sein soll oder nicht, nun können Sie loslegen. Hier ist ein Beispiel:

List<int> numbers = new List<int>()
{
    1, 2, 4, 7, 8, 16, 29, 32, 64, 128
};
List<int> excludedNumbers = new List<int>()
{
    7, 29
};
var validNumbers = numbers.Where(n => !excludedNumbers.Contains(n));
foreach (var n in validNumbers)
    Console.WriteLine(n);

In diesem Beispiel deklarieren wir eine zweite Liste von Zahlen - eine Art schwarze Liste von Zahlen, die wir nicht enthalten wollen! In der Where() -Methode verwenden wir die Contains() -Methode für die Blacklist, um zu entscheiden, ob eine Zahl in die endgültige Liste der Zahlen aufgenommen werden kann oder nicht.

Und natürlich funktioniert es für komplexere Objekte als Zahlen und Strings, und es ist immer noch sehr einfach zu bedienen. Sehen Sie sich dieses Beispiel an, in dem wir Objekte mit Benutzerinformationen anstelle von Zahlen verwenden und die Where() -Methode verwenden, um eine Liste von Benutzern mit Namen zu erhalten, die mit dem Buchstaben "J" im Alter von 39 oder weniger beginnen:

using System;
using System.Collections.Generic;
using System.Linq;

namespace LinqWhere2
{
    class Program
    {
static void Main(string[] args)
{
    List<User> listOfUsers = new List<User>()
    {
new User() { Name = "John Doe", Age = 42 },
new User() { Name = "Jane Doe", Age = 34 },
new User() { Name = "Joe Doe", Age = 8 },
new User() { Name = "Another Doe", Age = 15 },
    };

    var filteredUsers = listOfUsers.Where(user => user.Name.StartsWith("J") && user.Age < 40);
    foreach (User user in filteredUsers)
Console.WriteLine(user.Name + ": " + user.Age);
}


class User
{
    public string Name { get; set; }
    public int Age { get; set; }

}
    }
}

Und nur zum Vergleich: Hier sehen Sie, wie die where-Operation aussehen würde, wenn wir die abfragebasierte Syntax anstelle der Methode verwendet hätten:

// Method syntax
var filteredUsers = listOfUsers.Where(user => user.Name.StartsWith("J") && user.Age < 40);

// Query syntax
var filteredUsersQ = from user in listOfUsers where user.Name.StartsWith("J") && user.Age < 40 select user;

Verketten mehrerer Where() -Methoden

Wir haben dies kurz in der Einleitung zu LINQ diskutiert: Das tatsächliche Ergebnis eines LINQ-Ausdrucks wird nicht realisiert, bis Sie tatsächlich die Daten benötigen, z.B. wenn Sie Schleifen durchlaufen lassen, zählen Sie sie oder durchlaufen Sie sie (wie in unseren Beispielen). Das bedeutet auch, dass Sie mehrere Where() - Methoden miteinander verketten, wenn Sie das Gefühl haben, dass es leichter zu lesen ist - in sehr komplexen Ausdrücken kann es definitiv hilfreich sein! Hier ist eine modifizierte Version unseres vorherigen Beispiels:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n > 1).Where(n => n != 4).Where(n => n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

Das Ergebnis ist genau das gleiche, obwohl die erste Version möglicherweise nicht komplex genug war, um die Aufspaltung in mehrere Where() - Methodenaufrufe zu rechtfertigen, werden Sie wahrscheinlich in Situationen geraten, in denen es sinnvoll ist, dies zu tun. Ich möchte betonen, dass dies in Bezug auf die Leistung nicht extra kostet, weil die eigentlichen "Where" - Operationen nicht ausgeführt werden bis zu dem Teil, in dem wir das Ergebnis durchlaufen - bis dahin haben der Compiler und der Interpreter Ihre Anfrage optimiert, so schnell wie möglich zu sein, egal wie Sie diese geschrieben haben.

Zusammenfassung

Mit der Methode Where() können Sie unerwünschte Elemente problemlos aus Ihrer Datenquelle herausfiltern, um eine Teilmenge der ursprünglichen Daten zu erstellen. Denken Sie daran, dass es sich tatsächlich um eine neue Datenmenge handelt - die ursprüngliche Datenquelle bleibt unberührt, es sei denn, Sie überschreiben die ursprüngliche Variable ausdrücklich.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!