C# Academy · Lección

Where y filtrado

Seleccione los elementos coincidentes

Where y filtrado es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Qué hace Where

Where es el operador principal de filtrado de LINQ. Toma un predicado —una función que devuelve bool— y proporciona únicamente los elementos que lo satisfacen.

Se encuentra en System.Linq y funciona con cualquier IEnumerable<T>; devuelve una secuencia nueva en lugar de modificar el origen.

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

var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
var evens = nums.Where(n => n % 2 == 0);
Console.WriteLine(string.Join(", ", evens));

La lambda de predicado

El argumento de Where es una lambda n => condition. El parámetro representa cada elemento y el cuerpo debe evaluarse como true o false.

Devolver true conserva el elemento; false lo descarta. Puede utilizar cualquier expresión booleana.

using System;
using System.Linq;

string[] words = { "apple", "fig", "banana", "kiwi" };
var shortWords = words.Where(w => w.Length <= 4);
Console.WriteLine(string.Join(", ", shortWords));

Forma de sintaxis de consulta

LINQ ofrece una sintaxis de consulta que se lee como SQL. Una cláusula where filtra y select proyecta.

Se compila en las mismas llamadas a métodos, por lo que from x in src where ... select x es idéntico a src.Where(...). Use la forma que resulte más clara.

using System;
using System.Linq;

int[] scores = { 40, 75, 90, 55, 88 };
var passing = from s in scores
              where s >= 60
              select s;
Console.WriteLine(string.Join(", ", passing));

Combinación de condiciones

Dentro de un solo predicado puede combinar varias comprobaciones con && y ||. Esto mantiene el filtrado relacionado en una sola pasada.

Los paréntesis mejoran la legibilidad al combinar operadores, igual que en cualquier expresión booleana.

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

var ages = new List<int> { 12, 17, 21, 35, 64, 70 };
var adults = ages.Where(a => a >= 18 && a < 65);
Console.WriteLine(string.Join(", ", adults));

Encadenamiento de llamadas a Where

Puede encadenar varias llamadas a Where. Cada una filtra el resultado de la anterior, por lo que las condiciones se combinan mediante un AND lógico.

El encadenamiento puede resultar más claro que un único predicado extenso y permite combinar filtros creados en distintos lugares.

using System;
using System.Linq;

int[] data = { 3, 8, 15, 22, 27, 40 };
var result = data.Where(n => n > 5)
                 .Where(n => n % 2 == 0);
Console.WriteLine(string.Join(", ", result));

Where con índice

Una sobrecarga de Where expone el índice de base cero del elemento como segundo parámetro de la lambda. Esto resulta útil para filtrar según la posición.

Puede usarla, por ejemplo, para conservar un elemento de cada dos o para omitir el primer elemento según su índice.

using System;
using System.Linq;

string[] items = { "a", "b", "c", "d", "e" };
var evenIdx = items.Where((val, idx) => idx % 2 == 0);
Console.WriteLine(string.Join(", ", evenIdx));

Filtrado de objetos

El filtrado resulta especialmente útil con colecciones de objetos. El predicado puede leer cualquier propiedad de cada elemento.

Así se expresan las reglas de negocio —«clientes de esta ciudad», «pedidos por encima de un umbral»— de forma declarativa.

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

record Product(string Name, decimal Price);
var list = new List<Product> {
  new("Pen", 1.5m), new("Lamp", 20m), new("Mug", 8m) };
var cheap = list.Where(p => p.Price < 10);
foreach (var p in cheap) Console.WriteLine(p.Name);

Ejecución diferida

Where utiliza la ejecución diferida: no se ejecuta cuando se define, sino cuando se itera la secuencia, por ejemplo, en un foreach o al llamar a ToList.

Esto significa que los cambios realizados en el origen antes de la iteración se reflejan en el resultado.

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

var src = new List<int> { 1, 2 };
var q = src.Where(n => n > 1);
src.Add(5);
Console.WriteLine(string.Join(", ", q));

Coste de reevaluación

Como el filtrado es diferido, iterar dos veces la misma consulta vuelve a ejecutar el predicado dos veces. Esto puede resultar inesperado con predicados costosos u orígenes activos.

Cuando necesite una instantánea estable y reutilizable, materialícela una vez con ToList; lo veremos más adelante en este curso.

using System;
using System.Linq;

int calls = 0;
int[] nums = { 1, 2, 3 };
var q = nums.Where(n => { calls++; return n > 1; });
foreach (var _ in q) { }
foreach (var _ in q) { }
Console.WriteLine(calls);

Filtrar y luego contar

Un patrón habitual consiste en filtrar y después preguntar cuántos elementos coincidieron. Count puede recibir directamente un predicado, combinando el filtrado y el recuento.

count.Count(p => cond) equivale a seq.Where(p => cond).Count(), pero resulta más conciso.

using System;
using System.Linq;

int[] grades = { 55, 80, 42, 91, 67 };
int passed = grades.Count(g => g >= 60);
Console.WriteLine($"Passed: {passed}");

Los resultados vacíos no son un problema

Si ningún elemento satisface el predicado, Where simplemente proporciona una secuencia vacía; nunca null.

Esto permite encadenar filtros de forma segura: un resultado vacío pasa por los operadores posteriores sin necesidad de un tratamiento especial.

using System;
using System.Linq;

int[] nums = { 1, 2, 3 };
var big = nums.Where(n => n > 100);
Console.WriteLine($"Count: {big.Count()}");

Comprobación rápida

Compruebe su comprensión de la ejecución diferida.

Repaso

Where filtra una secuencia mediante un predicado booleano y devuelve un IEnumerable nuevo. Tiene una sobrecarga con índice, puede encadenarse o combinarse con &&/|| y funciona con objetos mediante sus propiedades.

Lo fundamental es que su ejecución es diferida: se ejecuta al iterar, por lo que volver a iterar provoca una nueva evaluación. A continuación daremos forma a lo que conservamos con Select.

Preguntas frecuentes

¿La lección «Where y filtrado» es gratis?

Sí — el texto completo de «Where y filtrado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Where y filtrado»?

Seleccione los elementos coincidentes Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Where y filtrado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy