Comparteix via

where (cláusula, Referencia de C#)

Use la where cláusula en una expresión de consulta para especificar qué elementos del origen de datos se van a devolver. Aplica una condición booleana (predicado) a cada elemento de origen (al que hace referencia la variable de rango) y devuelve los elementos para los que la condición especificada es true. Una expresión de consulta única puede contener varias where cláusulas y una sola cláusula puede contener varias subexpresiones de predicado.

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

En el ejemplo siguiente, la where cláusula filtra todos los números excepto los que son inferiores a cinco. Si quita la where cláusula , la consulta devuelve todos los números del origen de datos. La expresión num < 5 es el predicado que la consulta aplica a cada 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

Dentro de una sola where cláusula, puede especificar tantos predicados como sea necesario mediante los operadores && y || . En el ejemplo siguiente, la consulta especifica dos predicados para seleccionar solo los números par que son menores de cinco.

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 cláusula puede contener uno o varios métodos que devuelven valores booleanos. En el ejemplo siguiente, la where cláusula usa un método para determinar si el valor actual de la variable de rango es par o impar.

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

Observaciones

La where cláusula es un mecanismo de filtrado. Puede colocarlo casi en cualquier parte de una expresión de consulta, excepto que no puede ser la primera o la última cláusula. Una where cláusula puede aparecer antes o después de una cláusula group en función de si necesita filtrar los elementos de origen antes o después de agruparlos.

Si especifica un predicado que no es válido para los elementos del origen de datos, la consulta genera un error en tiempo de compilación. Este error es una ventaja de la comprobación de tipos segura que proporciona LINQ.

En tiempo de compilación, la where palabra clave se convierte en una llamada al Where método Operador de consulta estándar.

Consulte también

  • Last updated on