C# Language
Linq to Objects

introduzione

Come LINQ to Object esegue query

Le query LINQ non vengono eseguite immediatamente. Quando si crea la query, si sta semplicemente memorizzando la query per l'esecuzione futura. Solo quando si richiede effettivamente di iterare la query è la query eseguita (ad esempio in un ciclo for, quando si chiama ToList, Count, Max, Average, First, ecc.)

Questa è considerata un'esecuzione differita . Ciò consente di creare la query in più passaggi, potenzialmente modificandola in base a istruzioni condizionali e quindi eseguirla in un secondo momento solo dopo aver richiesto il risultato.

Dato il codice:

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

L'esempio sopra memorizza solo la query nella variabile di query . Non esegue la query stessa.

L'istruzione foreach forza l'esecuzione della query:

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

Alcuni metodi LINQ attivano anche l'esecuzione della query, Count , First , Max , Average . Restituiscono valori singoli. ToList e ToArray raccolgono i risultati e li trasformano rispettivamente in una lista o in una matrice.

Tenere presente che è possibile eseguire iterazioni sulla query più volte se si richiamano più funzioni LINQ sulla stessa query. Questo potrebbe dare risultati diversi ad ogni chiamata. Se vuoi lavorare con un solo set di dati, assicurati di salvarlo in un elenco o array.

Uso di LINQ su oggetti in C #

Una semplice query SELECT 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();
}

Nell'esempio sopra, una serie di stringhe (auto) viene utilizzata come una raccolta di oggetti da interrogare usando LINQ. In una query LINQ, la clausola from viene prima di tutto per introdurre l'origine dati (automobili) e la variabile range (auto). Quando viene eseguita la query, la variabile di intervallo servirà come riferimento per ciascun elemento successivo nelle automobili. Poiché il compilatore può inferire il tipo di auto, non è necessario specificarlo esplicitamente

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato:

SELEZIONA con una clausola WHERE

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

La clausola WHERE viene utilizzata per interrogare l'array di stringhe (macchine) per trovare e restituire un sottoinsieme di array che soddisfi la clausola WHERE.

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato:

Generazione di una lista ordinata

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

A volte è utile ordinare i dati restituiti. La clausola orderby causerà l'ordinamento degli elementi in base al confronto predefinito per il tipo da ordinare.

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato:

Lavorare con un tipo personalizzato

In questo esempio, un elenco tipizzato viene creato, popolato e quindi interrogato

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

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato:

Fino ad ora gli esempi non sembrano sorprendenti in quanto si può semplicemente ripetere l'array per fare praticamente lo stesso. Tuttavia, con i pochi esempi qui sotto puoi vedere come creare query più complesse con LINQ to Objects e ottenere di più con molto meno codice.

Nell'esempio seguente possiamo selezionare le auto che sono state vendute oltre 60000 unità e ordinarle sul numero di unità vendute:

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

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato:

Nell'esempio qui sotto possiamo selezionare le auto che hanno venduto un numero dispari di unità e ordinarle alfabeticamente sopra il suo nome:

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

Quando il codice sopra è compilato ed eseguito, produce il seguente risultato: