# GroupBy Linq Example

Grouping lists of data can be useful. In the example below I will outline basic grouping and how to group on multiple fields.

# A basic example

In this example, we have an array of people. Let's say we want to group these by Gender since this is common in each object. The result we are aiming for will be a list of genders. Then, within each gender group, we should have the people that fall under that gender. So, the resulting output should be 2 Genders, male and female. Within the male group, we should have Vernon and Thomas and in the female group, we should have Carrie. There are a few ways we can do this, so let's take a look at each one, and you can decide which you like or makes more sense to you.

# Method syntax 1

This method uses the .GroupBy method syntax and the lambda expression used specifies the Gender, like so: p => p.Gender. This is then chained to the Select method which produces a new anonymous object with the Gender and a list of people with the corresponding gender. The select method here is entirely optional and you can just have the .GroupBy method.

Live example: https://dotnetfiddle.net/MfuQxr

var people = new[]
    {
        new
            {
                Name = "Vernon",
                Gender = "Male",
            },
        new
            {
                Name = "Carrie",
                Gender = "Female"
            },
        new
            {
                Name = "Thomas",
                Gender = "Male"
            }
    };

//Method 1:
var peopleByGender = people.GroupBy(p => p.Gender)
                            .Select(x => new { Gender = x.Key, People = x }); 
// output:
// Male
//  Vernon
//  Thomas
// Female
//  Carrie

# Method syntax 2

This is a little more complex but results in the same output as the first. It combines the GroupBy and Select all in one method operation, which is convenient but may not be as readable at first. The first part of the lambda expression is the particular key to group by, which is Gender - same as Method 1. The next argument takes a Func which is essentially the selector. In other words, it's the .Select method statement in the first example.

Live example: https://dotnetfiddle.net/GYaf0z

var people = new[]
    {
        new
            {
                Name = "Vernon",
                Gender = "Male",
            },
        new
            {
                Name = "Carrie",
                Gender = "Female"
            },
        new
            {
                Name = "Thomas",
                Gender = "Male"
            }
    };

//Method 2:
var peopleByGender = people.GroupBy(arg => arg.Gender, 
                                   (key, list) => new {Gender = key, People = list});

// output:
// Male
//  Vernon
//  Thomas
// Female
//  Carrie

# Query syntax

Another way of grouping is, of course, using the Query syntax, which is my personal preference. It uses the following syntax to perform the group by: group [x] by [y] into [z]. Here, [x] is the particular object to be grouped, [y] is the key or property to group by and the into [z] is an alias of where the grouping result should reside in. So, the full statement is group person by person.Gender into g.

Live example: https://dotnetfiddle.net/WQO378

var people = new[]
    {
        new
            {
                Name = "Vernon",
                Gender = "Male",
            },
        new
            {
                Name = "Carrie",
                Gender = "Female"
            },
        new
            {
                Name = "Thomas",
                Gender = "Male"
            }
    };

//Method 3:
var peopleByGender = from person in people
                     group person by person.Gender
                     into g
                     select new {Gender = g.Key, People = g};

// output:
// Male
//  Vernon
//  Thomas
// Female
//  Carrie

# GroupBy - Multiple

In some cases, you may want to group by multiple properties or keys. In this example, we will group by Gender and City.

# Method syntax

Similar to the basic groupby example above, we can specify multiple properties using an anonymous object. Here we are using new { arg.Gender, arg.City }.

Live example: https://dotnetfiddle.net/4bMd42

var people = new[]
    {
        new
            {
                Name = "Vernon",
                Gender = "Male",
                City = "London",

            },
        new
            {
                Name = "Carrie",
                Gender = "Female",
                City = "London"
            },
            new
            {
                Name = "Joanna",
                Gender = "Female",
                City = "London"
            },
        new
            {
                Name = "Thomas",
                Gender = "Male",
                City = "Paris"
            }
    };

var peopleByGender = people.GroupBy(arg => new { arg.Gender, arg.City })
                           .Select(grouping => new
                           {
                              Gender = grouping.Key.Gender,
                              City = grouping.Key.City,
                              People = grouping
                           });

// output:
// Male London
//  Male London Vernon
// Female London
//  Female London Carrie
//  Female London Joanna
// Male Paris
//  Male Paris Thomas

# Query syntax

As with the method syntax, we too can use a similar anonymous object, new { p.Gender, p.City }.

Live example: https://dotnetfiddle.net/hIRlAv

var people = new[]
    {
        new
            {
                Name = "Vernon",
                Gender = "Male",
                City = "London",

            },
        new
            {
                Name = "Carrie",
                Gender = "Female",
                City = "London"
            },
            new
            {
                Name = "Joanna",
                Gender = "Female",
                City = "London"
            },
        new
            {
                Name = "Thomas",
                Gender = "Male",
                City = "Paris"
            }
    };

var peopleByGender = from p in people
                     group p by new { p.Gender, p.City } // this is how to group by multiple properties
                     into g
                     select new
                     {
                        City = g.Key.City,
                        Gender = g.Key.Gender,
                        People = g
                     };

// output:
// Male London
//  Male London Vernon
// Female London
//  Female London Carrie
//  Female London Joanna
// Male Paris
//  Male Paris Thomas

# GroupBy - Batching

This particular grouping can be useful at times. If you have a large list and would like to break them up into groups of say 5, this particular method of grouping is pretty neat.

This can be useful in various scenarios. They can range from UI purposes to server-side improvements.

So, the example below,

# Method syntax

Here we have a list of 12 currencies with exchange rates. We are going to break this list into groups of 5. The end result would be 2 batches of 5 and 1 batch of 2.

Live example: https://dotnetfiddle.net/jUxGcZ

var exchangeRates = new[]
                    {
                        new {Currency = "USD", Rate = 1.2701},
                        new {Currency = "JPY", Rate = 138.97},
                        new {Currency = "BGN", Rate = 1.9558},
                        new {Currency = "CZK", Rate = 27.54},
                        new {Currency = "DKK", Rate = 7.4432},
                        new {Currency = "GBP", Rate = 0.7827},
                        new {Currency = "HUF", Rate = 312.18},
                        new {Currency = "LTL", Rate = 3.4528},
                        new {Currency = "PLN", Rate = 4.1827},
                        new {Currency = "RON", Rate = 4.4125},
                        new {Currency = "SEK", Rate = 9.2018},
                        new {Currency = "CHF", Rate = 1.2071},
                    };

var batchNumber = 5;    // the batch size
var batches = exchangeRates.Select((exchangeRate, index) =>
                            new {ExchangeRate = exchangeRate, Index = index})
                           .GroupBy(x => x.Index/batchNumber);

// output:
// ------------
// Batch no: 1
// ------------
// 1 : USD 1.2701
// 2 : JPY 138.97
// 3 : BGN 1.9558
// 4 : CZK 27.54
// 5 : DKK 7.4432
// ------------
// Batch no: 2
// ------------
// 1 : GBP 0.7827
// 2 : HUF 312.18
// 3 : LTL 3.4528
// 4 : PLN 4.1827
// 5 : RON 4.4125
// ------------
// Batch no: 3
// ------------
// 1 : SEK 9.2018
// 2 : CHF 1.2071

# Query syntax

I'll admit, I'm cheating a little here with the query syntax. I'm using the .Select method with an index and combining it with the query syntax. But I hope to get the message across. Live example: https://dotnetfiddle.net/Mxk1LB

var exchangeRates = new[]
                    {
                        new {Currency = "USD", Rate = 1.2701},
                        new {Currency = "JPY", Rate = 138.97},
                        new {Currency = "BGN", Rate = 1.9558},
                        new {Currency = "CZK", Rate = 27.54},
                        new {Currency = "DKK", Rate = 7.4432},
                        new {Currency = "GBP", Rate = 0.7827},
                        new {Currency = "HUF", Rate = 312.18},
                        new {Currency = "LTL", Rate = 3.4528},
                        new {Currency = "PLN", Rate = 4.1827},
                        new {Currency = "RON", Rate = 4.4125},
                        new {Currency = "SEK", Rate = 9.2018},
                        new {Currency = "CHF", Rate = 1.2071},
                    };

var batchNumber = 5;    // the batch size

var batches2 = from e in exchangeRates.Select((exchangeRate, index) =>
                                       new {ExchangeRate = exchangeRate, Index = index})
                                       group new {e.ExchangeRate, e.Index}
                                       by e.Index/batchNumber
                                       into groupedBatches
                                       select groupedBatches;

// output:
// ------------
// Batch no: 1
// ------------
// 1 : USD 1.2701
// 2 : JPY 138.97
// 3 : BGN 1.9558
// 4 : CZK 27.54
// 5 : DKK 7.4432
// ------------
// Batch no: 2
// ------------
// 1 : GBP 0.7827
// 2 : HUF 312.18
// 3 : LTL 3.4528
// 4 : PLN 4.1827
// 5 : RON 4.4125
// ------------
// Batch no: 3
// ------------
// 1 : SEK 9.2018
// 2 : CHF 1.2071