Condividi tramite

clausola where (Riferimenti per C#)

Utilizzare la where clausola in un'espressione di query per specificare gli elementi dell'origine dati da restituire. Applica una condizione booleana (predicato) a ogni elemento di origine (a cui fa riferimento la variabile di intervallo) e restituisce gli elementi per i quali la condizione specificata è true. Una singola espressione di query può contenere più where clausole e una singola clausola può contenere più sottoespressioni predicate.

Il riferimento al linguaggio C# documenta la versione rilasciata più di recente del linguaggio C#. Contiene anche la documentazione iniziale per le funzionalità nelle versioni di anteprima pubblica per la prossima versione del linguaggio di programmazione.

La documentazione identifica tutte le funzionalità introdotte nelle ultime tre versioni della lingua o nelle anteprime pubbliche correnti.

Suggerimento

Per trovare quando una funzionalità è stata introdotta per la prima volta in C#, vedere l'articolo sulla cronologia delle versioni del linguaggio C#.

Nell'esempio seguente la where clausola filtra tutti i numeri tranne quelli minori di cinque. Se si rimuove la where clausola , la query restituisce tutti i numeri dall'origine dati. L'espressione num < 5 è il predicato applicato dalla query a ogni elemento.

class WhereSample
{
    static void Main()
    {
        // Simple data source. Arrays support IEnumerable<T>.
        int[] numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0];

        // Simple query with one predicate in where clause.
        var queryLowNums =
            from num in numbers
            where num < 5
            select num;

        // Execute the query.
        foreach (var s in queryLowNums)
        {
            Console.Write(s.ToString() + " ");
        }
    }
}
//Output: 4 1 3 2 0

All'interno di una singola where clausola, è possibile specificare il numero di predicati necessari usando gli operatori && e || . Nell'esempio seguente la query specifica due predicati per selezionare solo i numeri pari minori di cinque.

class WhereSample2
{
static void Main()
{
    // Data source.
    int[] numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0];

    // Create the query with two predicates in where clause.
    var queryLowNums2 =
        from num in numbers
        where num < 5 && num % 2 == 0
        select num;

    // Execute the query
    foreach (var s in queryLowNums2)
    {
        Console.Write(s.ToString() + " ");
    }
    Console.WriteLine();

    // Create the query with two where clause.
    var queryLowNums3 =
        from num in numbers
        where num < 5
        where num % 2 == 0
        select num;

    // Execute the query
    foreach (var s in queryLowNums3)
    {
        Console.Write(s.ToString() + " ");
    }
}
}
// Output:
// 4 2 0
// 4 2 0

Una where clausola può contenere uno o più metodi che restituiscono valori booleani. Nell'esempio seguente la where clausola usa un metodo per determinare se il valore corrente della variabile di intervallo è pari o dispari.

class WhereSample3
{
    static void Main()
    {
        // Data source
        int[] numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0];

        // Create the query with a method call in the where clause.
        // Note: This won't work in LINQ to SQL unless you have a
        // stored procedure that is mapped to a method by this name.
        var queryEvenNums =
            from num in numbers
            where IsEven(num)
            select num;

         // Execute the query.
        foreach (var s in queryEvenNums)
        {
            Console.Write(s.ToString() + " ");
        }
    }

    // Method may be instance method or static method.
    static bool IsEven(int i) => i % 2 == 0;
}
//Output: 4 8 6 2 0

Osservazioni:

La where clausola è un meccanismo di filtro. È possibile posizionarla quasi ovunque in un'espressione di query, ad eccezione del fatto che non può essere la prima o l'ultima clausola. Una where clausola può essere visualizzata prima o dopo una clausola group a seconda che sia necessario filtrare gli elementi di origine prima o dopo che sono raggruppati.

Se si specifica un predicato non valido per gli elementi nell'origine dati, la query genera un errore in fase di compilazione. Questo errore è uno dei vantaggi del controllo dei tipi sicuro fornito da LINQ.

In fase di compilazione, la where parola chiave viene convertita in una chiamata al Where metodo Operatore query standard.

Vedere anche

  • Last updated on