where, clause (Référence C#)where clause (C# Reference)

La clause where est utilisée dans une expression de requête pour spécifier les éléments de la source de données qui seront retournés dans l’expression de requête.The where clause is used in a query expression to specify which elements from the data source will be returned in the query expression. Elle applique une condition booléenne (un prédicat) à chaque élément source (référencé par la variable de portée) et retourne ceux pour lesquels la condition spécifiée est remplie.It applies a Boolean condition (predicate) to each source element (referenced by the range variable) and returns those for which the specified condition is true. Une expression de requête unique peut contenir plusieurs clauses where et une clause unique peut contenir plusieurs sous-expressions de prédicat.A single query expression may contain multiple where clauses and a single clause may contain multiple predicate subexpressions.

ExemplesExample

Dans l’exemple suivant, la clause where élimine par filtrage tous les nombres excepté ceux inférieurs à cinq.In the following example, the where clause filters out all numbers except those that are less than five. Si vous supprimez la clause where, tous les nombres de la source de données seront retournés.If you remove the where clause, all numbers from the data source would be returned. L’expression num < 5 est le prédicat qui est appliqué à chaque élément.The expression num < 5 is the predicate that is applied to each element.

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

ExemplesExample

Dans une clause where unique, vous pouvez spécifier autant de prédicats que nécessaire à l’aide des opérateurs && et ||.Within a single where clause, you can specify as many predicates as necessary by using the && and || operators. Dans l’exemple suivant, la requête spécifie deux prédicats pour sélectionner uniquement les nombres pairs inférieurs à cinq.In the following example, the query specifies two predicates in order to select only the even numbers that are less than five.

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

ExemplesExample

Une clause where peut contenir une ou plusieurs méthodes qui retournent des valeurs booléennes.A where clause may contain one or more methods that return Boolean values. Dans l’exemple suivant, la clause where utilise une méthode pour déterminer si la valeur actuelle de la variable de portée est paire ou impaire.In the following example, the where clause uses a method to determine whether the current value of the range variable is even or odd.

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)
    {
        return i % 2 == 0;
    }    
}
//Output: 4 8 6 2 0

RemarquesRemarks

La clause where est un mécanisme de filtrage.The where clause is a filtering mechanism. Elle peut être placée à presque n’importe quel endroit d’une expression de requête, sauf qu’elle ne peut pas être la première ni la dernière clause.It can be positioned almost anywhere in a query expression, except it cannot be the first or last clause. Une clause where peut apparaître avant ou après une clause group selon que vous devez filtrer les éléments sources avant ou après leur regroupement.A where clause may appear either before or after a group clause depending on whether you have to filter the source elements before or after they are grouped.

Si un prédicat spécifié n’est pas valide pour les éléments de la source de données, une erreur de compilation est générée.If a specified predicate is not valid for the elements in the data source, a compile-time error will result. C’est l’un des avantages de la vérification de type fort fourni par LINQLINQ.This is one benefit of the strong type-checking provided by LINQLINQ.

Au moment de la compilation, le mot clé where est converti en appel à la méthode d’opérateur de requête standard Where.At compile time the where keyword is converted into a call to the Where Standard Query Operator method.

Voir aussiSee also