Grouping Operators: GroupBy & ToLookup

In this tutorial, we will learn about Grouping operators - GroupBy & ToLookup in LINQ.

Grouping Operator

In LINQ, grouping operators does the same thing as SQL’s GROUP BY clause in SQL query. In this tutorial, we will learn about the sorting operator - GroupBy & ToLookup.

GroupBy

The GroupBy() method does the same thing as the Group By clause in SQL query. The GroupBy() used to group the collection items based on the specified key and it returns the collection of IGrouping<Key, Values>.

The GroupBy() method has 8 overload methods. You can learn more about GroupBy() overload methods

Examples of GroupBy Operator

Example 1: GroupBy - Query Syntax

In this example, we create a group of employees who have the same salary. Employees who has the same salary are in the same collection and each grouped collection has the key and collection, where the key will be the salary and the collection which contains the Employee data whose salary matches the key. For example:

Example 1: GroupBy - Query Syntax

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

namespace LinqPrograms
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            // Employee collection
            IList<Employee> employeelist = new List<Employee>() {
                new Employee() { EmpID = 1, EmpName = "John", City = "New York", Salary = 130000} ,
                new Employee() { EmpID = 2, EmpName = "Moin", City = "New Orleans", Salary = 250000 } ,
                new Employee() { EmpID = 3, EmpName = "Bill", City = "Seattle", Salary = 180000 } ,
                new Employee() { EmpID = 4, EmpName = "Ram" , City = "Delhi", Salary = 200000} ,
                new Employee() { EmpID = 5, EmpName = "Ron" , City = "San Jose", Salary = 180000 },
                new Employee() { EmpID = 6, EmpName = "Bill" , City = "Chicago", Salary = 250000 }
            };

            // LINQ Query Syntax to GroupBy Data based on Salary
            Console.WriteLine("--Employee Grouped by their Salary--");
            var GroupByResult = from emp in employeelist
                               group emp by emp.Salary;

            foreach (var empSalary in GroupByResult)
            {
                Console.WriteLine($"Salary group: {empSalary.Key}");
                foreach(var emp in empSalary )
                {
                    Console.WriteLine($"Employee Name: {emp.EmpName}; City: {emp.City};");
                }
                Console.WriteLine();
            }           

            Console.ReadKey();
        }

    }

    public class Employee
    {
        public int EmpID { get; set; }
        public string EmpName { get; set; }
        public string City { get; set; }
        public int Salary { get; set; }
    }

}

Output

--Employee Grouped by their Salary--
Salary group: 130000
Employee Name: John; City: New York;

Salary group: 250000
Employee Name: Moin; City: New Orleans;
Employee Name: Bill; City: Chicago;

Salary group: 180000
Employee Name: Bill; City: Seattle;
Employee Name: Ron; City: San Jose;

Salary group: 200000
Employee Name: Ram; City: Delhi;

Example 2: GroupBy() - Method Syntax

The GroupBy() extension method works the same way in the method syntax as in query syntax. In the method syntax, you need to specify the lambda expression for the specified key field in the Groupby() extension method. Here is the example of GroupBy() method with method Syntax:

Example 2: GroupBy() - Method Syntax

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

namespace LinqPrograms
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            // Employee collection
            IList<Employee> employeelist = new List<Employee>() {
                new Employee() { EmpID = 1, EmpName = "John", City = "New York", Salary = 130000} ,
                new Employee() { EmpID = 2, EmpName = "Moin", City = "New Orleans", Salary = 250000 } ,
                new Employee() { EmpID = 3, EmpName = "Bill", City = "Seattle", Salary = 180000 } ,
                new Employee() { EmpID = 4, EmpName = "Ram" , City = "Delhi", Salary = 200000} ,
                new Employee() { EmpID = 5, EmpName = "Ron" , City = "San Jose", Salary = 180000 },
                new Employee() { EmpID = 6, EmpName = "Bill" , City = "Chicago", Salary = 250000 }
            };

            // LINQ Method Syntax to GroupBy Data based on Salary
            Console.WriteLine("--Employee Grouped by their Salary--");
            var GroupByResult = employeelist.GroupBy(x => x.Salary);
                               

            foreach (var empSalary in GroupByResult)
            {
                Console.WriteLine($"Salary group: {empSalary.Key}");
                foreach(var emp in empSalary )
                {
                    Console.WriteLine($"Employee Name: {emp.EmpName}; City: {emp.City};");
                }
                Console.WriteLine();
            }           

            Console.ReadKey();
        }

    }

    public class Employee
    {
        public int EmpID { get; set; }
        public string EmpName { get; set; }
        public string City { get; set; }
        public int Salary { get; set; }
    }

}

Output

ToLookup

The ToLookup() extension method works the same as the Groupby() method. The only difference between both the methods is execution of methods. The GroupBy() method execution is deferred whereas the ToLookup() method execution is immediate.

The ToLookup() method is not supported in the query syntax.

Examples of ToLookup Operator

Example: ToLookup - Query Syntax

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

namespace LinqPrograms
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            // Employee collection
            IList<Employee> employeelist = new List<Employee>() {
                new Employee() { EmpID = 1, EmpName = "John", City = "New York", Salary = 130000} ,
                new Employee() { EmpID = 2, EmpName = "Moin", City = "New Orleans", Salary = 250000 } ,
                new Employee() { EmpID = 3, EmpName = "Bill", City = "Seattle", Salary = 180000 } ,
                new Employee() { EmpID = 4, EmpName = "Ram" , City = "Delhi", Salary = 200000} ,
                new Employee() { EmpID = 5, EmpName = "Ron" , City = "San Jose", Salary = 180000 },
                new Employee() { EmpID = 6, EmpName = "Bill" , City = "Chicago", Salary = 250000 }
            };

            // LINQ Method Syntax to GroupBy Data based on Salary
            Console.WriteLine("--Employee Grouped by their Salary--");
            var GroupByResult = employeelist.ToLookup(x => x.Salary);
                               

            foreach (var empSalary in GroupByResult)
            {
                Console.WriteLine($"Salary group: {empSalary.Key}");
                foreach(var emp in empSalary )
                {
                    Console.WriteLine($"Employee Name: {emp.EmpName}; City: {emp.City};");
                }
                Console.WriteLine();
            }           

            Console.ReadKey();
        }

    }

    public class Employee
    {
        public int EmpID { get; set; }
        public string EmpName { get; set; }
        public string City { get; set; }
        public int Salary { get; set; }
    }

}

Output

Key Points to Remember

GroupBy - Grouping Data by Key: The GroupBy operator in LINQ is used to group elements of a collection based on a specific key. It creates collections of groups where each group contains elements that share the same key. This is useful when you need to organize data based on common attributes.
Deferred Execution Applies: Like many LINQ operators, GroupBy follows deferred execution. This means the grouping operation doesn’t happen until the collection is iterated over, either through a loop, a .ToList() call, or another terminal operation.
Customizing Grouping with a Result Selector: The GroupBy operator allows you to provide a custom result selector, which lets you project or shape the grouped data into a new form. This is useful if you want to transform the grouped elements while grouping them.
GroupBy Returns an IEnumerable<IGrouping<TKey, TElement>>: The result of a GroupBy operation is a collection of IGrouping objects. Each IGrouping object represents a group, containing both the key (the grouping criterion) and the collection of elements that belong to that group.
ToLookup: Similar to GroupBy, But with Immediate Execution: ToLookup works similarly to GroupBy, but with immediate execution. This means that when you call ToLookup, the operation is performed immediately, and the result is stored in memory as a Lookup<TKey, TElement> collection.
Lookup Is Immutable and Indexable: A Lookup created by ToLookup is immutable and can be indexed. You can access groups directly by their key, making it easier to retrieve specific groups without needing to iterate through the entire collection.
Handling Non-Existent Keys in ToLookup: One of the unique features of ToLookup is that it returns an empty collection when you access a non-existent key. This makes it more fault-tolerant compared to a dictionary, where accessing a non-existent key would throw an exception.
Custom Key Comparers for Both GroupBy and ToLookup: Both GroupBy and ToLookup allow you to use custom comparers for key comparison. This is useful when you need case-insensitive grouping or grouping based on culture-specific rules.
Choosing Between GroupBy and ToLookup:
- Use GroupBy when you need deferred execution or if you need a more flexible result shape (like custom projections).
- Use ToLookup when you want immediate execution, indexing capability, and the assurance that accessing non-existent keys won’t throw an exception.

Learn Joining Operator - Join in the next tutorial.