C# Language
Linq to Objects

Introduction

Comment LINQ to Object exécute les requêtes

Les requêtes LINQ ne s'exécutent pas immédiatement. Lorsque vous créez la requête, vous stockez simplement la requête pour une exécution ultérieure. Ce n'est que lorsque vous demandez réellement à effectuer une itération de la requête que la requête est exécutée (par exemple, dans une boucle for, lorsque vous appelez ToList, Count, Max, Average, First, etc.)

Ceci est considéré comme une exécution différée . Cela vous permet de construire la requête en plusieurs étapes, en la modifiant potentiellement en fonction d'instructions conditionnelles, puis de l'exécuter ultérieurement, une fois que vous avez demandé le résultat.

Vu le code:

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

L'exemple ci-dessus stocke uniquement la requête dans query variable de query . Il n'exécute pas la requête elle-même.

L'instruction foreach force l'exécution de la requête:

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

Certaines méthodes LINQ déclenchent également l'exécution de la requête, Count , First , Max , Average . Ils renvoient des valeurs uniques. ToList et ToArray collectent les résultats et les transforment respectivement en une liste ou en un tableau.

Sachez qu'il est possible de parcourir plusieurs fois la requête si vous appelez plusieurs fonctions LINQ sur la même requête. Cela pourrait vous donner des résultats différents à chaque appel. Si vous souhaitez uniquement travailler avec un ensemble de données, veillez à le sauvegarder dans une liste ou un tableau.

Utiliser LINQ to Objects dans C #

Une simple requête SELECT dans 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();
}

Dans l'exemple ci-dessus, un tableau de chaînes (cars) est utilisé comme une collection d'objets à interroger à l'aide de LINQ. Dans une requête LINQ, la clause from vient en premier pour introduire la source de données (cars) et la variable range (car). Lorsque la requête est exécutée, la variable range servira de référence à chaque élément successif dans les voitures. Comme le compilateur peut déduire le type de voiture, vous n'avez pas à le spécifier explicitement

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

SELECT avec une clause WHERE

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

La clause WHERE est utilisée pour interroger le tableau de chaînes (cars) pour rechercher et renvoyer un sous-ensemble de tableau qui satisfait à la clause WHERE.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Génération d'une liste ordonnée

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

Parfois, il est utile de trier les données renvoyées. La clause orderby entraînera le tri des éléments en fonction du comparateur par défaut pour le type en cours de tri.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Travailler avec un type personnalisé

Dans cet exemple, une liste saisie est créée, renseignée puis interrogée

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Jusqu'à présent, les exemples ne semblent pas étonnants, car on peut simplement parcourir le tableau pour faire la même chose. Cependant, avec les quelques exemples ci-dessous, vous pouvez voir comment créer des requêtes plus complexes avec LINQ to Objects et obtenir plus avec beaucoup moins de code.

Dans l'exemple ci-dessous, nous pouvons sélectionner des voitures qui ont été vendues à plus de 60000 unités et les classer en fonction du nombre d'unités vendues:

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());

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Dans l'exemple ci-dessous, nous pouvons sélectionner les voitures qui ont vendu un nombre impair d'unités et les classer par ordre alphabétique sur leur nom:

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant: