Filtrar datos: el método Where ().

Una de las operaciones más básicas (pero también más poderosas) que puede realizar en un conjunto de datos es filtrar algunos de ellos. Ya vimos un vistazo de lo que puede hacer con el método Where () en el artículo de introducción de LINQ, pero en este artículo, profundizaremos un poco más. Ya discutimos cuántos métodos LINQ pueden usar una expresión de Lambda para realizar su tarea y el método Where () es uno de ellos: proporcionará cada elemento como entrada y luego proporcionará la lógica que decide si el elemento es o no incluido (devuelve verdadero) o excluido (devuelve falso) del resultado final. Aquí hay un ejemplo básico:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

En este ejemplo, cada número se compara con nuestra expresión, que devolverá verdadero si el número es menor que 10 y falso si es 10 o mayor. Como resultado, obtenemos una versión de la lista original, donde solo hemos incluido números por debajo de 10, que luego se envían a la consola.

Pero la expresión no tiene que ser tan simple como eso: podemos agregarle fácilmente más requisitos, como si fuera una declaración if regular:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n > 1 && n != 4 &&  n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

Especificamos que el número debe ser mayor que 1, pero no el número específico 4 y menor que 10.

Por supuesto, también puede usar varios métodos para llamar a su expresión, siempre que el resultado final sea un valor booleano, de modo que el método Where () sepa si desea incluir el elemento en cuestión o no, está listo. Aquí hay un ejemplo:

List<int> numbers = new List<int>()
{
    1, 2, 4, 7, 8, 16, 29, 32, 64, 128
};
List<int> excludedNumbers = new List<int>()
{
    7, 29
};
var validNumbers = numbers.Where(n => !excludedNumbers.Contains(n));
foreach (var n in validNumbers)
    Console.WriteLine(n);

En este ejemplo, declaramos una segunda lista de números, ¡una especie de lista negra de números que no queremos incluir! En el método Where (), utilizamos el método Contains () en la lista negra, para decidir si un número se puede incluir en la lista final de números o no.

Y, por supuesto, funciona para objetos más complejos que los números y las cadenas, y sigue siendo muy fácil de usar. Solo eche un vistazo a este ejemplo, donde usamos objetos con información del usuario en lugar de números, y usamos el método Where () para obtener una lista de usuarios con nombres que comienzan con la letra "J", a la edad de 39 años o menos:

using System;
using System.Collections.Generic;
using System.Linq;

namespace LinqWhere2
{
    class Program
    {
    static void Main(string[] args)
    {
        List<User> listOfUsers = new List<User>()
        {
        new User() { Name = "John Doe", Age = 42 },
        new User() { Name = "Jane Doe", Age = 34 },
        new User() { Name = "Joe Doe", Age = 8 },
        new User() { Name = "Another Doe", Age = 15 },
        };

        var filteredUsers = listOfUsers.Where(user => user.Name.StartsWith("J") && user.Age < 40);
        foreach (User user in filteredUsers)
        Console.WriteLine(user.Name + ": " + user.Age);
    }


    class User
    {
        public string Name { get; set; }
        public int Age { get; set; }

    }
    }
}

Y solo para comparar, así es como se vería la operación where si hubiéramos utilizado la sintaxis basada en consultas en lugar la basada en el método:

// Method syntax
var filteredUsers = listOfUsers.Where(user => user.Name.StartsWith("J") && user.Age < 40);

// Query syntax
var filteredUsersQ = from user in listOfUsers where user.Name.StartsWith("J") && user.Age < 40 select user;

Encadenamiento de múltiples métodos Where ().

Discutimos esto brevemente en la introducción a LINQ: el resultado real de una expresión LINQ no se realiza hasta que realmente necesita los datos, p.e. cuando lo recorre el bucle, cuenta o itera sobre él (como lo hacemos en nuestros ejemplos). Eso también significa que encadena múltiples métodos Where () juntos, si cree que es más fácil de leer, ¡en expresiones muy complejas, definitivamente puede ser! Aquí hay una versión modificada de nuestro ejemplo anterior:

List<int> numbers = new List<int>()
{
    1, 2, 4, 8, 16, 32
};
var smallNumbers = numbers.Where(n => n > 1).Where(n => n != 4).Where(n => n < 10);
foreach (var n in smallNumbers)
    Console.WriteLine(n);

El resultado es exactamente el mismo, y aunque la primera versión podría no haber sido lo suficientemente compleja como para justificar la división en múltiples llamadas al método Where (), es probable que se encuentre con situaciones en las que tenga sentido hacerlo. Quiero enfatizar que esto no cuesta más, en términos de rendimiento, porque las operaciones reales de "where" no se llevan a cabo hasta la parte en la que hacemos un bucle sobre el resultado; para entonces, el compilador y el intérprete tendrán optimizó su consulta para que sea lo más rápida posible, sin importar cómo la haya escrito.

Resumen.

Con el método Where () , puede filtrar fácilmente los elementos no deseados de su fuente de datos, para crear un subconjunto de los datos originales. Recuerde que en realidad se trata de un nuevo conjunto de datos: la fuente de datos original no se modificará a menos que anule específicamente la variable original.