Como: resultados de consulta de grupo (guia de programação do C#)
O agrupamento é um dos mais poderosos recursos de LINQ.Os exemplos a seguir mostram como agrupar dados de várias maneiras:
Por uma propriedade simples.
Pela primeiro carta de uma propriedade de cadeia de caracteres.
Por um intervalo numérico computado.
Predicado booleano ou outra expressão.
Por uma chave composta.
Além disso, as duas últimas consultas projeto seus resultados em um novo tipo anônimo que contém somente o aluno 's primeiro e o sobrenome.Para obter mais informações, consulte o cláusula Group (referência de C#).
Exemplo
Todos os exemplos neste tópico usam as seguintes fontes de dados e classes auxiliares.
public class StudentClass
{
#region data
protected enum GradeLevel { FirstYear = 1, SecondYear, ThirdYear, FourthYear };
protected class Student
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int ID { get; set; }
public GradeLevel Year;
public List<int> ExamScores;
}
protected static List<Student> students = new List<Student>
{
new Student {FirstName = "Terry", LastName = "Adams", ID = 120,
Year = GradeLevel.SecondYear,
ExamScores = new List<int>{ 99, 82, 81, 79}},
new Student {FirstName = "Fadi", LastName = "Fakhouri", ID = 116,
Year = GradeLevel.ThirdYear,
ExamScores = new List<int>{ 99, 86, 90, 94}},
new Student {FirstName = "Hanying", LastName = "Feng", ID = 117,
Year = GradeLevel.FirstYear,
ExamScores = new List<int>{ 93, 92, 80, 87}},
new Student {FirstName = "Cesar", LastName = "Garcia", ID = 114,
Year = GradeLevel.FourthYear,
ExamScores = new List<int>{ 97, 89, 85, 82}},
new Student {FirstName = "Debra", LastName = "Garcia", ID = 115,
Year = GradeLevel.ThirdYear,
ExamScores = new List<int>{ 35, 72, 91, 70}},
new Student {FirstName = "Hugo", LastName = "Garcia", ID = 118,
Year = GradeLevel.SecondYear,
ExamScores = new List<int>{ 92, 90, 83, 78}},
new Student {FirstName = "Sven", LastName = "Mortensen", ID = 113,
Year = GradeLevel.FirstYear,
ExamScores = new List<int>{ 88, 94, 65, 91}},
new Student {FirstName = "Claire", LastName = "O'Donnell", ID = 112,
Year = GradeLevel.FourthYear,
ExamScores = new List<int>{ 75, 84, 91, 39}},
new Student {FirstName = "Svetlana", LastName = "Omelchenko", ID = 111,
Year = GradeLevel.SecondYear,
ExamScores = new List<int>{ 97, 92, 81, 60}},
new Student {FirstName = "Lance", LastName = "Tucker", ID = 119,
Year = GradeLevel.ThirdYear,
ExamScores = new List<int>{ 68, 79, 88, 92}},
new Student {FirstName = "Michael", LastName = "Tucker", ID = 122,
Year = GradeLevel.FirstYear,
ExamScores = new List<int>{ 94, 92, 91, 91}},
new Student {FirstName = "Eugene", LastName = "Zabokritski", ID = 121,
Year = GradeLevel.FourthYear,
ExamScores = new List<int>{ 96, 85, 91, 60}}
};
#endregion
//Helper method, used in GroupByRange.
protected static int GetPercentile(Student s)
{
double avg = s.ExamScores.Average();
return avg > 0 ? (int)avg / 10 : 0;
}
public void QueryHighScores(int exam, int score)
{
var highScores = from student in students
where student.ExamScores[exam] > score
select new {Name = student.FirstName, Score = student.ExamScores[exam]};
foreach (var item in highScores)
{
Console.WriteLine("{0,-15}{1}", item.Name, item.Score);
}
}
}
public class Program
{
public static void Main()
{
StudentClass sc = new StudentClass();
sc.QueryHighScores(1, 90);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
O exemplo a seguir mostra como agrupar os elementos de origem, usando uma única propriedade do elemento como a chave de grupo.Nesse caso, a chave é um string, sobrenome do aluno.Também é possível usar uma subseqüência de caracteres para a chave.A operação de agrupamento usa o comparador de igualdade padrão para o tipo.
Cole o seguinte método para o StudentClass classe.Alterar a instrução de chamada na Main método para sc.GroupBySingleProperty().
public void GroupBySingleProperty()
{
Console.WriteLine("Group by a single property in an object:");
// Variable queryLastNames is an IEnumerable<IGrouping<string,
// DataClass.Student>>.
var queryLastNames =
from student in students
group student by student.LastName into newGroup
orderby newGroup.Key
select newGroup;
foreach (var nameGroup in queryLastNames)
{
Console.WriteLine("Key: {0}", nameGroup.Key);
foreach (var student in nameGroup)
{
Console.WriteLine("\t{0}, {1}", student.LastName, student.FirstName);
}
}
}
/* Output:
Group by a single property in an object:
Key: Adams
Adams, Terry
Key: Fakhouri
Fakhouri, Fadi
Key: Feng
Feng, Hanying
Key: Garcia
Garcia, Cesar
Garcia, Debra
Garcia, Hugo
Key: Mortensen
Mortensen, Sven
Key: O'Donnell
O'Donnell, Claire
Key: Omelchenko
Omelchenko, Svetlana
Key: Tucker
Tucker, Lance
Tucker, Michael
Key: Zabokritski
Zabokritski, Eugene
*/
O exemplo a seguir mostra como agrupar os elementos de origem usando algo diferente de uma propriedade do objeto para a chave de grupo.Neste exemplo, a chave é a primeira letra do sobrenome do aluno.
Cole o seguinte método para o StudentClass classe.Alterar a instrução de chamada na Main método para sc.GroupBySubstring().
public void GroupBySubstring()
{
Console.WriteLine("\r\nGroup by something other than a property of the object:");
var queryFirstLetters =
from student in students
group student by student.LastName[0];
foreach (var studentGroup in queryFirstLetters)
{
Console.WriteLine("Key: {0}", studentGroup.Key);
// Nested foreach is required to access group items.
foreach (var student in studentGroup)
{
Console.WriteLine("\t{0}, {1}", student.LastName, student.FirstName);
}
}
}
/* Output:
Group by something other than a property of the object:
Key: A
Adams, Terry
Key: F
Fakhouri, Fadi
Feng, Hanying
Key: G
Garcia, Cesar
Garcia, Debra
Garcia, Hugo
Key: M
Mortensen, Sven
Key: O
O'Donnell, Claire
Omelchenko, Svetlana
Key: T
Tucker, Lance
Tucker, Michael
Key: Z
Zabokritski, Eugene
*/
O exemplo a seguir mostra como agrupar os elementos de origem usando um intervalo numérico como uma chave de grupo.A consulta, em seguida, projeta os resultados em um tipo anônimo que contém apenas o nome e sobrenome e o intervalo de percentil ao qual pertence o aluno.Um tipo anônimo é usado porque não é necessário usar o completo Student o objeto para exibir os resultados.GetPercentileSe uma função auxiliar que calcula um percentil baseia a pontuação média do aluno.O método retorna um número inteiro entre 0 e 10.
//Helper method, used in GroupByRange.
protected static int GetPercentile(Student s)
{
double avg = s.ExamScores.Average();
return avg > 0 ? (int)avg / 10 : 0;
}
Cole o seguinte método para o StudentClass classe.Alterar a instrução de chamada na Main método para sc.GroupByRange().
public void GroupByRange()
{
Console.WriteLine("\r\nGroup by numeric range and project into a new anonymous type:");
var queryNumericRange =
from student in students
let percentile = GetPercentile(student)
group new { student.FirstName, student.LastName } by percentile into percentGroup
orderby percentGroup.Key
select percentGroup;
// Nested foreach required to iterate over groups and group items.
foreach (var studentGroup in queryNumericRange)
{
Console.WriteLine("Key: {0}", (studentGroup.Key * 10));
foreach (var item in studentGroup)
{
Console.WriteLine("\t{0}, {1}", item.LastName, item.FirstName);
}
}
}
/* Output:
Group by numeric range and project into a new anonymous type:
Key: 60
Garcia, Debra
Key: 70
O'Donnell, Claire
Key: 80
Adams, Terry
Feng, Hanying
Garcia, Cesar
Garcia, Hugo
Mortensen, Sven
Omelchenko, Svetlana
Tucker, Lance
Zabokritski, Eugene
Key: 90
Fakhouri, Fadi
Tucker, Michael
*/
O exemplo a seguir mostra como agrupar os elementos de origem usando uma expressão de comparação booleanos.Neste exemplo, a expressão booleana testa se a pontuação média de exame de um aluno é maior do que 75.Como nos exemplos anteriores, os resultados são projetados para um tipo anônimo porque o elemento de origem completa não é necessária.Observe que as propriedades de tipo anônimo se tornam propriedades sobre o Key membro e podem ser acessados por nome, quando a consulta é executada.
Cole o seguinte método para o StudentClass classe.Alterar a instrução de chamada na Main método para sc.GroupByBoolean().
public void GroupByBoolean()
{
Console.WriteLine("\r\nGroup by a Boolean into two groups with string keys");
Console.WriteLine("\"True\" and \"False\" and project into a new anonymous type:");
var queryGroupByAverages = from student in students
group new { student.FirstName, student.LastName }
by student.ExamScores.Average() > 75 into studentGroup
select studentGroup;
foreach (var studentGroup in queryGroupByAverages)
{
Console.WriteLine("Key: {0}", studentGroup.Key);
foreach (var student in studentGroup)
Console.WriteLine("\t{0} {1}", student.FirstName, student.LastName);
}
}
/* Output:
Group by a Boolean into two groups with string keys
"True" and "False" and project into a new anonymous type:
Key: True
Terry Adams
Fadi Fakhouri
Hanying Feng
Cesar Garcia
Hugo Garcia
Sven Mortensen
Svetlana Omelchenko
Lance Tucker
Michael Tucker
Eugene Zabokritski
Key: False
Debra Garcia
Claire O'Donnell
*/
O exemplo a seguir mostra como usar um tipo anônimo para encapsular uma chave que contém vários valores.Neste exemplo, o primeiro valor da chave é a primeira letra do sobrenome do aluno.O segundo valor da chave é um booleano que especifica se o aluno pontuado mais 85 sobre o exame de primeiro.Você pode solicitar os grupos por qualquer propriedade na chave.
Cole o seguinte método para o StudentClass classe.Alterar a instrução de chamada na Main método para sc.GroupByCompositeKey().
public void GroupByCompositeKey()
{
var queryHighScoreGroups =
from student in students
group student by new { FirstLetter = student.LastName[0],
Score = student.ExamScores[0] > 85 } into studentGroup
orderby studentGroup.Key.FirstLetter
select studentGroup;
Console.WriteLine("\r\nGroup and order by a compound key:");
foreach (var scoreGroup in queryHighScoreGroups)
{
string s = scoreGroup.Key.Score == true ? "more than" : "less than";
Console.WriteLine("Name starts with {0} who scored {1} 85", scoreGroup.Key.FirstLetter, s);
foreach (var item in scoreGroup)
{
Console.WriteLine("\t{0} {1}", item.FirstName, item.LastName);
}
}
}
/* Output:
Group and order by a compound key:
Name starts with A who scored more than 85
Terry Adams
Name starts with F who scored more than 85
Fadi Fakhouri
Hanying Feng
Name starts with G who scored more than 85
Cesar Garcia
Hugo Garcia
Name starts with G who scored less than 85
Debra Garcia
Name starts with M who scored more than 85
Sven Mortensen
Name starts with O who scored less than 85
Claire O'Donnell
Name starts with O who scored more than 85
Svetlana Omelchenko
Name starts with T who scored less than 85
Lance Tucker
Name starts with T who scored more than 85
Michael Tucker
Name starts with Z who scored more than 85
Eugene Zabokritski
*/
Compilando o código
Copie e cole cada método que você deseja testar para o StudentClass classe.Adicionar uma instrução de chamada para o método para o Main método e pressione F5.
Quando você adapta esses métodos para seu próprio aplicativo, lembre-se de que o LINQ requer a versão 3.5 ou 4 da .NET Framework, e que o projeto deve conter uma referência a System.Core.dll e o uso de uma diretriz para System. LINQ.LINQ to SQL, LINQ to XML e LINQ to DataSet tipos requerem adicionais usando as diretivas e referências.Para obter mais informações, consulte Como: criar um projeto LINQ.
Consulte também
Tarefas
Como: executar uma subconsulta em uma operação de agrupamento (guia de programação do C#)
Como: criar um grupo aninhado (guia de programação do C#)
Referência
cláusula Group (referência de C#)
Tipos anônimos (guia de programação do C#)