# Group query results

Grouping is one of the most powerful capabilities of LINQ. The following examples show how to group data in various ways:

• By a single property.

• By the first letter of a string property.

• By a computed numeric range.

• By Boolean predicate or other expression.

• By a compound key.

In addition, the last two queries project their results into a new anonymous type that contains only the student's first and last name. For more information, see the group clause.

Note

The examples in this topic use the Student class and students list from the sample code in Query a collection of objects.

## Group by single property example

The following example shows how to group source elements by using a single property of the element as the group key. In this case the key is a string, the student's last name. It is also possible to use a substring for the key; see the next example. The grouping operation uses the default equality comparer for the type.

// Variable queryLastNames is an IEnumerable<IGrouping<string,
// DataClass.Student>>.
var groupByLastNamesQuery =
from student in students
group student by student.LastName into newGroup
orderby newGroup.Key
select newGroup;

foreach (var nameGroup in groupByLastNamesQuery)
{
Console.WriteLine($"Key: {nameGroup.Key}"); foreach (var student in nameGroup) { Console.WriteLine($"\t{student.LastName}, {student.FirstName}");
}
}

/* Output:
Key: Fakhouri
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
*/


## Group by value example

The following example shows how to group source elements by using something other than a property of the object for the group key. In this example, the key is the first letter of the student's last name.

var groupByFirstLetterQuery =
from student in students
group student by student.LastName[0];

foreach (var studentGroup in groupByFirstLetterQuery)
{
Console.WriteLine($"Key: {studentGroup.Key}"); // Nested foreach is required to access group items. foreach (var student in studentGroup) { Console.WriteLine($"\t{student.LastName}, {student.FirstName}");
}
}

/* Output:
Key: A
Key: F
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
*/


## Group by a range example

The following example shows how to group source elements by using a numeric range as a group key. The query then projects the results into an anonymous type that contains only the first and last name and the percentile range to which the student belongs. An anonymous type is used because it is not necessary to use the complete Student object to display the results. GetPercentile is a helper function that calculates a percentile based on the student's average score. The method returns an integer between 0 and 10.

int GetPercentile(Student s)
{
double avg = s.ExamScores.Average();
return avg > 0 ? (int)avg / 10 : 0;
}

var groupByPercentileQuery =
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 groupByPercentileQuery)
{
Console.WriteLine($"Key: {studentGroup.Key * 10}"); foreach (var item in studentGroup) { Console.WriteLine($"\t{item.LastName}, {item.FirstName}");
}
}

/* Output:
Key: 60
Garcia, Debra
Key: 70
O'Donnell, Claire
Key: 80
Feng, Hanying
Garcia, Cesar
Garcia, Hugo
Mortensen, Sven
Omelchenko, Svetlana
Tucker, Lance
Zabokritski, Eugene
Key: 90
Tucker, Michael
*/


## Group by comparison example

The following example shows how to group source elements by using a Boolean comparison expression. In this example, the Boolean expression tests whether a student's average exam score is greater than 75. As in previous examples, the results are projected into an anonymous type because the complete source element is not needed. Note that the properties in the anonymous type become properties on the Key member and can be accessed by name when the query is executed.

var groupByHighAverageQuery =
from student in students
group new
{
student.FirstName,
student.LastName
} by student.ExamScores.Average() > 75 into studentGroup
select studentGroup;

foreach (var studentGroup in groupByHighAverageQuery)
{
Console.WriteLine($"Key: {studentGroup.Key}"); foreach (var student in studentGroup) { Console.WriteLine($"\t{student.FirstName} {student.LastName}");
}
}

/* Output:
Key: True
Hanying Feng
Cesar Garcia
Hugo Garcia
Sven Mortensen
Svetlana Omelchenko
Lance Tucker
Michael Tucker
Eugene Zabokritski
Key: False
Debra Garcia
Claire O'Donnell
*/


## Group by anonymous type

The following example shows how to use an anonymous type to encapsulate a key that contains multiple values. In this example, the first key value is the first letter of the student's last name. The second key value is a Boolean that specifies whether the student scored over 85 on the first exam. You can order the groups by any property in the key.

var groupByCompoundKey =
from student in students
group student by new
{
FirstLetter = student.LastName[0],
IsScoreOver85 = student.ExamScores[0] > 85
} into studentGroup
orderby studentGroup.Key.FirstLetter
select studentGroup;

foreach (var scoreGroup in groupByCompoundKey)
{
string s = scoreGroup.Key.IsScoreOver85 == true ? "more than 85" : "less than 85";
Console.WriteLine($"Name starts with {scoreGroup.Key.FirstLetter} who scored {s}"); foreach (var item in scoreGroup) { Console.WriteLine($"\t{item.FirstName} {item.LastName}");
}
}

/* Output:
Name starts with A who scored more than 85
Name starts with F who scored more than 85
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
*/