C# Academy · Aula

OrderBy e agrupamento

Ordene e agrupe os resultados

OrderBy e agrupamento é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 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.

Ordenando com OrderBy

OrderBy ordena uma sequência em ordem crescente pela chave que você escolher. A função anônima retorna o valor usado na ordenação.

Ele retorna uma nova sequência ordenada e é estável, o que significa que os elementos com chaves iguais mantêm sua ordem relativa original.

using System;
using System.Linq;

int[] nums = { 4, 1, 3, 2 };
var sorted = nums.OrderBy(n => n);
Console.WriteLine(string.Join(", ", sorted));

Ordem decrescente

OrderByDescending ordena da maior para a menor chave selecionada.

Use-o diretamente em vez de ordenar em ordem crescente e inverter — assim, a intenção fica clara e a ordenação é feita em uma única passagem.

using System;
using System.Linq;

int[] scores = { 70, 95, 60, 88 };
var ranked = scores.OrderByDescending(s => s);
Console.WriteLine(string.Join(", ", ranked));

Ordenando por uma propriedade

Para objetos, selecione a propriedade pela qual deseja ordenar. OrderBy(p => p.Age) ordena as pessoas da mais jovem à mais velha.

A chave pode ser qualquer tipo comparável — números, cadeias de caracteres, datas — ou qualquer tipo que implemente IComparable.

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

record P(string Name, int Age);
var people = new List<P> { new("Ana", 30), new("Bo", 22) };
var byAge = people.OrderBy(p => p.Age);
foreach (var p in byAge) Console.WriteLine(p.Name);

Ordenação secundária com ThenBy

ThenBy adiciona um critério de desempate. Depois de OrderBy, ele ordena os elementos que compartilham a chave principal por uma segunda chave.

Você pode encadear várias chamadas de ThenBy/ThenByDescending para obter uma ordenação em vários níveis.

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

record P(string Name, int Age);
var people = new List<P> { new("Bo", 30), new("Ana", 30), new("Cy", 22) };
var ordered = people.OrderBy(p => p.Age).ThenBy(p => p.Name);
foreach (var p in ordered) Console.WriteLine($"{p.Age} {p.Name}");

Por que não usar um segundo OrderBy

Chamar OrderBy duas vezes não cria um critério de desempate: a segunda chamada reordena tudo e descarta a ordenação anterior.

Para fazer uma ordenação em camadas, use sempre ThenBy depois do OrderBy inicial.

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

record P(string N, int A);
var ps = new List<P> { new("Bo", 30), new("Ana", 30) };
var wrong = ps.OrderBy(p => p.A).OrderBy(p => p.N);
foreach (var p in wrong) Console.WriteLine(p.N);

Ordenação na sintaxe de consulta

A sintaxe de consulta tem uma cláusula orderby. Liste várias chaves separadas por vírgulas, opcionalmente com descending.

orderby p.Age, p.Name descending ordena por idade e, em caso de empate, por nome em ordem inversa.

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

record P(string N, int A);
var ps = new List<P> { new("Bo", 30), new("Ana", 30), new("Cy", 22) };
var q = from p in ps orderby p.A, p.N select p.N;
Console.WriteLine(string.Join(", ", q));

Agrupamento com GroupBy

GroupBy divide uma sequência em grupos que compartilham uma chave. Ele retorna uma sequência de IGrouping<TKey, TElement>.

Cada agrupamento expõe sua Key e é iterável sobre os elementos daquele grupo.

using System;
using System.Linq;

int[] nums = { 1, 2, 3, 4, 5, 6 };
var groups = nums.GroupBy(n => n % 2 == 0 ? "even" : "odd");
foreach (var g in groups)
  Console.WriteLine($"{g.Key}: {string.Join(\",\", g)}");

Chave e membros do grupo

A Key de cada grupo identifica a partição, e iterar pelo grupo produz seus membros. Você pode chamar Count() diretamente em um grupo.

É assim que você cria histogramas, contagens e divisões por categoria.

using System;
using System.Linq;

string[] fruit = { "apple", "avocado", "banana", "cherry" };
var byLetter = fruit.GroupBy(f => f[0]);
foreach (var g in byLetter)
  Console.WriteLine($"{g.Key}: {g.Count()}");

Agrupar e depois projetar

Um padrão comum projeta cada grupo em um objeto de resumo usando Select depois de GroupBy.

Você lê a Key e agrega os membros, por exemplo, calculando uma contagem ou uma soma por grupo.

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

record Sale(string City, int Amt);
var sales = new List<Sale> { new("NY", 5), new("LA", 3), new("NY", 2) };
var totals = sales.GroupBy(s => s.City)
                  .Select(g => new { g.Key, Sum = g.Sum(x => x.Amt) });
foreach (var t in totals) Console.WriteLine($"{t.Key}={t.Sum}");

GroupBy com seletor de elementos

GroupBy tem uma sobrecarga que recebe uma segunda lambda — um seletor de elementos — que define o que cada grupo armazena, e não apenas como ele é agrupado.

Aqui, agrupamos por cidade, mas armazenamos apenas os valores.

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

record Sale(string City, int Amt);
var sales = new List<Sale> { new("NY", 5), new("NY", 2) };
var g = sales.GroupBy(s => s.City, s => s.Amt);
foreach (var grp in g)
  Console.WriteLine($"{grp.Key}: {string.Join(\",\", grp)}");

A ordenação e o agrupamento são adiados

Tanto OrderBy quanto GroupBy usam execução adiada: eles são executados quando enumerados. Porém, observe que a ordenação e o agrupamento precisam consumir toda a fonte para produzir o primeiro elemento.

Portanto, ao contrário de Where, eles não processam os dados em fluxo; o custo ocorre na primeira iteração.

using System;
using System.Linq;

int[] nums = { 3, 1, 2 };
var q = nums.OrderBy(n => n);
Console.WriteLine("Query built");
Console.WriteLine(string.Join(", ", q));

Verificação rápida

Pense sobre a ordenação em vários níveis.

Recapitulação

OrderBy/OrderByDescending ordenam por uma chave; ThenBy adiciona critérios de desempate. Um segundo OrderBy reordena tudo e não funciona como critério de desempate.

GroupBy divide os dados em objetos IGrouping com uma Key e membros, que muitas vezes são projetados em resumos. Ambos são adiados, mas consomem toda a fonte. Em seguida, agregaremos e materializaremos os resultados.

Perguntas Frequentes

A aula “OrderBy e agrupamento” é grátis?

Sim — o texto completo de “OrderBy e agrupamento” é 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 “OrderBy e agrupamento”?

Ordene e agrupe os resultados 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 3 de 4.

Quanto tempo leva a aula “OrderBy e agrupamento”?

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