C# Language
Linq zu Objekten

Einführung

Wie LINQ to Object Abfragen ausführt

LINQ-Abfragen werden nicht sofort ausgeführt. Wenn Sie die Abfrage erstellen, speichern Sie sie einfach für die zukünftige Ausführung. Nur wenn Sie tatsächlich die Abfrage wiederholen möchten, wird die Abfrage ausgeführt (z. B. in einer for-Schleife, beim Aufruf von ToList, Count, Max, Average, First usw.).

Dies wird als aufgeschobene Ausführung betrachtet . Auf diese Weise können Sie die Abfrage in mehreren Schritten aufbauen, möglicherweise basierend auf Bedingungsanweisungen ändern und sie später nur dann ausführen, wenn Sie das Ergebnis benötigen.

Gegeben der Code:

var query = from n in numbers 
            where n % 2 != 0
            select n;

Im obigen Beispiel wird die Abfrage nur in der query gespeichert. Die Abfrage wird nicht ausgeführt.

Die foreach Anweisung erzwingt die Abfrageausführung:

foreach(var n in query) {
    Console.WriteLine($"Number selected {n}");
}

Einige LINQ-Methoden lösen auch die Abfrageausführung aus: Count , First , Max , Average . Sie geben einzelne Werte zurück. ToList und ToArray sammelt das Ergebnis und ToArray sie in eine Liste bzw. ein Array um.

Beachten Sie, dass Sie die Abfrage mehrmals durchlaufen können, wenn Sie mehrere LINQ-Funktionen für dieselbe Abfrage aufrufen. Dies kann bei jedem Anruf zu unterschiedlichen Ergebnissen führen. Wenn Sie nur mit einem Datensatz arbeiten möchten, müssen Sie ihn in einer Liste oder einem Array speichern.

Verwenden von LINQ zu Objekten in c #

Eine einfache SELECT-Abfrage in Linq

static void Main(string[] args)
{
    string[] cars = { "VW Golf", 
                        "Opel Astra", 
                        "Audi A4", 
                        "Ford Focus", 
                        "Seat Leon", 
                        "VW Passat", 
                        "VW Polo", 
                        "Mercedes C-Class" };

    var list = from car in cars
               select car;

    StringBuilder sb = new StringBuilder();

    foreach (string entry in list)
    {
        sb.Append(entry + "\n");
    }

    Console.WriteLine(sb.ToString());
    Console.ReadLine();
}

Im obigen Beispiel wird ein Array von Strings (Autos) als eine Sammlung von Objekten verwendet, die mit LINQ abgefragt werden sollen. In einer LINQ-Abfrage steht die from-Klausel an erster Stelle, um die Datenquelle (cars) und die Bereichsvariable (car) einzuführen. Wenn die Abfrage ausgeführt wird, dient die Bereichsvariable als Referenz für jedes nachfolgende Element in Autos. Da der Compiler auf den Fahrzeugtyp schließen kann, müssen Sie ihn nicht explizit angeben

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

SELECT mit einer WHERE-Klausel

var list = from car in cars
           where car.Contains("VW")
           select car;

Die WHERE-Klausel wird verwendet, um das String-Array (cars) abzufragen, um eine Teilmenge des Arrays zu suchen und zurückzugeben, die die WHERE-Klausel erfüllt.

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

Eine geordnete Liste erstellen

var list = from car in cars
           orderby car ascending 
           select car;

Manchmal ist es nützlich, die zurückgegebenen Daten zu sortieren. Die orderby-Klausel bewirkt, dass die Elemente nach dem Standardvergleicher für den zu sortierenden Typ sortiert werden.

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

Mit einem benutzerdefinierten Typ arbeiten

In diesem Beispiel wird eine typisierte Liste erstellt, gefüllt und dann abgefragt

public class Car
{
    public String Name { get; private set; }
    public int UnitsSold { get; private set; }

    public Car(string name, int unitsSold)
    {
        Name = name;
        UnitsSold = unitsSold;
    }
}

class Program
{
    static void Main(string[] args)
    {

        var car1 = new Car("VW Golf", 270952);
        var car2 = new Car("Opel Astra", 56079);
        var car3 = new Car("Audi A4", 52493);
        var car4 = new Car("Ford Focus", 51677);
        var car5 = new Car("Seat Leon", 42125);
        var car6 = new Car("VW Passat", 97586);
        var car7 = new Car("VW Polo", 69867);
        var car8 = new Car("Mercedes C-Class", 67549);

        var cars = new List<Car> { 
            car1, car2, car3, car4, car5, car6, car7, car8 };
        var list = from car in cars
                   select car.Name;

        foreach (var entry in list)
        {
            Console.WriteLine(entry);
        }
        Console.ReadLine();
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

Bis jetzt scheinen die Beispiele nicht erstaunlich zu sein, da man einfach durch das Array iterieren kann, um im Grunde dasselbe zu tun. In den folgenden Beispielen können Sie jedoch sehen, wie Sie komplexere Abfragen mit LINQ to Objects erstellen und mit viel weniger Code mehr erreichen.

Im folgenden Beispiel können wir Autos auswählen, die über 60000 Einheiten verkauft wurden, und sie nach der Anzahl der verkauften Einheiten sortieren:

var list = from car in cars
           where car.UnitsSold > 60000 
           orderby car.UnitsSold descending 
           select car;

StringBuilder sb = new StringBuilder();

foreach (var entry in list)
{
    sb.AppendLine($"{entry.Name} - {entry.UnitsSold}");
}
Console.WriteLine(sb.ToString());

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

Im folgenden Beispiel können wir Autos auswählen, die eine ungerade Anzahl von Einheiten verkauft haben, und diese alphabetisch nach ihrem Namen sortieren:

var list = from car in cars
           where car.UnitsSold % 2 != 0 
           orderby car.Name ascending 
           select car;

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis: