C# Academy · Aula

WHERE e filtragem

Selecione elementos correspondentes

WHERE e filtragem é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que Where faz

Where é o operador central de filtragem do LINQ. Ele recebe um predicado — uma função que retorna bool — e produz somente os elementos que o satisfazem.

Ele pertence a System.Linq e funciona com qualquer IEnumerable<T>, retornando uma nova sequência em vez de modificar a fonte.

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));

A função anônima do predicado

O argumento de Where é uma função anônima n => condition. O parâmetro representa cada elemento, e o corpo deve ser avaliado como true ou false.

Retornar true mantém o elemento; false o descarta. Qualquer expressão booleana funciona.

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 sintaxe de consulta

O LINQ oferece uma sintaxe de consulta que se parece com SQL. Uma cláusula where filtra, e select faz a projeção.

Ela é compilada nas mesmas chamadas de método, portanto from x in src where ... select x é idêntico a src.Where(...). Use a forma que for mais 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));

Combinando condições

Dentro de um único predicado, você pode combinar várias verificações com && e ||. Isso mantém a filtragem relacionada em uma única passagem.

Os parênteses ajudam na legibilidade ao combinar operadores, assim como em qualquer expressão 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));

Encadeando chamadas de Where

Você pode encadear várias chamadas de Where. Cada uma filtra o resultado da anterior, portanto as condições se combinam com o AND lógico.

Às vezes, o encadeamento é mais claro do que um predicado muito grande e permite compor filtros criados em lugares diferentes.

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 com índice

Uma sobrecarga de Where expõe o índice baseado em zero do elemento como um segundo parâmetro da função anônima. Isso é útil para filtragens baseadas na posição.

Use-a para manter, por exemplo, um elemento a cada dois ou para ignorar o primeiro item com base no í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));

Filtrando objetos

A filtragem é especialmente útil em coleções de objetos. O predicado pode ler qualquer propriedade de cada elemento.

É assim que você expressa regras de negócio — "clientes nesta cidade", "pedidos acima de um limite" — 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);

Execução adiada

Where usa execução adiada: ele não é executado quando definido, mas somente quando a sequência é percorrida, por exemplo em um foreach ou ao chamar ToList.

Isso significa que as alterações feitas na fonte antes da iteração são refletidas no 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));

Custo da reavaliação

Como a filtragem é adiada, percorrer a mesma consulta duas vezes executa o predicado novamente nas duas ocasiões. Isso pode ser inesperado com predicados dispendiosos ou fontes dinâmicas.

Quando precisar de uma cópia estável e reutilizável, materialize-a uma vez com ToList — assunto abordado mais adiante neste 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 e depois contar

Um padrão comum é filtrar e depois perguntar quantos elementos corresponderam. Count pode receber um predicado diretamente, combinando filtro e contagem.

count.Count(p => cond) equivale a seq.Where(p => cond).Count(), mas é mais conciso.

using System;
using System.Linq;

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

Resultados vazios não são um problema

Se nenhum elemento satisfizer o predicado, Where simplesmente produzirá uma sequência vazia — nunca null.

Isso torna os filtros seguros para encadear: um resultado vazio passa pelos operadores seguintes sem tratamento especial.

using System;
using System.Linq;

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

Verificação rápida

Teste sua compreensão da execução adiada.

Recapitulação

Where filtra uma sequência usando um predicado booleano e retorna um novo IEnumerable. Ele tem uma sobrecarga com índice, pode ser encadeado ou combinado com &&/|| e funciona com objetos por meio de suas propriedades.

O mais importante é que sua execução é adiada — ele é executado durante a iteração, portanto percorrê-lo novamente faz com que seja reavaliado. A seguir, definiremos o que manter com Select.

Perguntas Frequentes

A aula “WHERE e filtragem” é grátis?

Sim — o texto completo de “WHERE e filtragem” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “WHERE e filtragem”?

Selecione elementos correspondentes Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “WHERE e filtragem”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy