GroupBy, Join, Aggregate, projeções (tipos anônimos)
Agrupe itens, una sequências, reduza com Aggregate e projete resultados limpos usando tipos anônimos.
GroupBy, Join, Aggregate, projeções (tipos anônimos) é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.
Visão geral dos operadores avançados
Hoje:
- GroupBy: cria grupos por chave
- Join: combina duas sequências por uma chave
- Aggregate: reduz para um único valor
- Tipos anónimos: projeções organizadas
Agrupamento por chave
GroupBy cria grupos com uma Key e uma sequência interna de itens que partilham essa chave.
using System;
using System.Linq;
public class Program
{
public static void Main(string[] args)
{
string[] words = new string[] { "ant", "cat", "tiger", "lion", "dog", "eagle" };
var groups = words.GroupBy(w => w.Length);
foreach (var g in groups)
{
Console.WriteLine("Len " + g.Key + ":");
foreach (string w in g) Console.WriteLine(" - " + w);
}
}
}
Junção interna por chave
Join associa itens de duas sequências pela chave e projeta o resultado combinado.
using System;
using System.Linq;
public sealed class Customer { public int Id; public string Name; public Customer(int id, string name){ Id=id; Name=name; } }
public sealed class Order { public int CustomerId; public string Item; public Order(int cid, string item){ CustomerId=cid; Item=item; } }
public class Program
{
public static void Main(string[] args)
{
var customers = new Customer[] { new Customer(1,"Ada"), new Customer(2,"Bob") };
var orders = new Order[] { new Order(1,"Book"), new Order(1,"Pen"), new Order(2,"Map") };
var joined = customers.Join(
orders,
c => c.Id,
o => o.CustomerId,
(c, o) => c.Name + " -> " + o.Item);
foreach (string s in joined) Console.WriteLine(s);
}
}
Noções básicas de Aggregate
Aggregate aplica um acumulador para reduzir uma sequência a um único resultado. Escolha um valor inicial adequado.
using System;
using System.Linq;
public class Program
{
public static void Main(string[] args)
{
int[] xs = new int[] { 1, 2, 3, 4 };
// Product with seed 1
int product = xs.Aggregate(1, (acc, n) => acc * n);
Console.WriteLine("Product = " + product); // 24
// Join words with a separator using seed
string[] words = new string[] { "a", "b", "c" };
string csv = words.Aggregate("", (acc, w) => acc == "" ? w : acc + "," + w);
Console.WriteLine(csv); // a,b,c
}
}
Projeção de tipo anónimo
Utilize tipos anónimos para obter projeções organizadas: new { Name = c.Name, ... } ou a forma abreviada new { c.Name }.
using System;
using System.Linq;
public sealed class City { public string Name; public int Pop; public City(string n,int p){ Name=n; Pop=p; } }
public class Program
{
public static void Main(string[] args)
{
var cities = new City[]
{
new City("Oslo", 634000),
new City("Rome", 2873000),
new City("Riga", 605000)
};
var small = cities
.Where(c => c.Pop < 1000000)
.Select(c => new { c.Name, Millions = (c.Pop / 1000000.0) });
foreach (var x in small)
{
Console.WriteLine(x.Name + " ~ " + x.Millions + "M");
}
}
}
Dicas práticas
Dicas:
- Depois de GroupBy, percorra primeiro os grupos e depois os itens.
- Utilize Join quando tiver duas origens com chaves correspondentes.
- Escolha um valor inicial adequado para Aggregate.
- Os tipos anónimos são locais; devolva DTOs concretos a partir de APIs públicas.
Objetivo do GroupBy
Recapitulação
Recapitulação: utilize GroupBy para criar grupos, Join para combinar origens, Aggregate para reduzir e tipos anónimos para obter projeções claras.
Perguntas Frequentes
A aula “GroupBy, Join, Aggregate, projeções (tipos anônimos)” é grátis?
Sim — o texto completo de “GroupBy, Join, Aggregate, projeções (tipos anônimos)” é 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 3 aulas no total.
O que vou aprender em “GroupBy, Join, Aggregate, projeções (tipos anônimos)”?
Agrupe itens, una sequências, reduza com Aggregate e projete resultados limpos usando tipos anônimos. 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 3.
Quanto tempo leva a aula “GroupBy, Join, Aggregate, projeções (tipos anônimos)”?
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
- GroupBy, Join, Aggregate, projeções (tipos anônimos)
- Materialização (ToList, ToDictionary) e observações de desempenho
- Dicas de composição