GroupBy operation in C Sharp (C#) - Step-by-Step Execution

Concept Flow - GroupBy operation

Start with collection

↓

Pick each item

↓

Find key for item

↓

Add item to group with that key

↓

Repeat for all items

↓

Return groups as collection of groups

GroupBy takes each item, finds a key, and puts items with the same key together in groups.

Execution Sample

C Sharp (C#)

var numbers = new[] {1, 2, 3, 4, 5, 6};
var groups = numbers.GroupBy(n => n % 2 == 0 ? "Even" : "Odd");
foreach (var group in groups) {
  Console.WriteLine(group.Key);
  foreach (var num in group) Console.WriteLine(num);
}

Groups numbers into "Even" and "Odd" groups and prints each group and its numbers.

Execution Table

Step	Current Item	Key Computed	Groups So Far	Action
1	1	Odd	{"Odd": [1]}	Create 'Odd' group and add 1
2	2	Even	{"Odd": [1], "Even": [2]}	Create 'Even' group and add 2
3	3	Odd	{"Odd": [1,3], "Even": [2]}	Add 3 to 'Odd' group
4	4	Even	{"Odd": [1,3], "Even": [2,4]}	Add 4 to 'Even' group
5	5	Odd	{"Odd": [1,3,5], "Even": [2,4]}	Add 5 to 'Odd' group
6	6	Even	{"Odd": [1,3,5], "Even": [2,4,6]}	Add 6 to 'Even' group
7	-	-	-	All items processed, grouping complete

💡 All items processed, grouping complete

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	Final
groups	{}	{"Odd": [1]}	{"Odd": [1], "Even": [2]}	{"Odd": [1,3], "Even": [2]}	{"Odd": [1,3], "Even": [2,4]}	{"Odd": [1,3,5], "Even": [2,4]}	{"Odd": [1,3,5], "Even": [2,4,6]}	{"Odd": [1,3,5], "Even": [2,4,6]}

Key Moments - 2 Insights

Why does the GroupBy create new groups only sometimes?

A new group is created only when the key for the current item does not exist yet in groups. See steps 1 and 2 in execution_table where 'Odd' and 'Even' groups are created.

Are items reordered when grouped?

No, items keep their original order within each group. Look at the groups in variable_tracker after each step; items are added in the order they appear.

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What is the key computed for the current item?

A Odd

B Even

C 1

D 2

💡 Hint

Check the 'Key Computed' column at step 3 in execution_table.

At which step does the 'Even' group first get created?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Groups So Far' column to see when 'Even' appears.

If the grouping key was changed to n % 3, how would the number of groups change?

A There would be 2 groups

B There would be 6 groups

C There would be 3 groups

D There would be 1 group

💡 Hint

Think about possible remainders when dividing by 3: 0, 1, or 2.

Concept Snapshot

GroupBy operation groups items by a key.
Syntax: collection.GroupBy(item => key)
Creates groups where all items share the same key.
Groups keep original item order.
Useful to organize data by categories.

Full Transcript

The GroupBy operation in C# takes a collection and groups its items by a key you define. For each item, it calculates a key and adds the item to the group with that key. If the group does not exist yet, it creates it. This example groups numbers into 'Even' and 'Odd' groups by checking if the number is divisible by 2. The execution table shows each step: the current item, the key found, the groups so far, and the action taken. The variable tracker shows how the groups grow after each item is processed. Beginners often wonder when new groups are created and if items reorder; groups are created only when a new key appears, and items keep their order inside groups. The visual quiz tests understanding of keys, group creation steps, and how changing the key affects groups. The quick snapshot summarizes how to use GroupBy and what it does.

Practice

1. What does the GroupBy method do in C#?

easy

A. It sorts elements in ascending order.

B. It groups elements of a collection based on a key selector.

C. It filters elements based on a condition.

D. It removes duplicate elements from a collection.

Solution

1. Step 1: Understand the purpose of GroupBy

   The GroupBy method organizes elements by a key, creating groups of items sharing the same key.

2. Step 2: Compare with other operations

   Sorting arranges order, filtering selects items, and removing duplicates eliminates repeats, which are different from grouping.

3. Final Answer:

   It groups elements of a collection based on a key selector. -> Option B

4. Quick Check:

   GroupBy = grouping by key [OK]

Hint: GroupBy always creates groups by a key, not sorting or filtering [OK]

Common Mistakes:

• Confusing GroupBy with sorting methods
• Thinking GroupBy filters items
• Assuming GroupBy removes duplicates

2. Which of the following is the correct syntax to group a list of strings by their first character using LINQ in C#?

easy

A. var groups = list.GroupBy(s => s[0]);

B. var groups = list.GroupBy(s => s.Length);

C. var groups = list.GroupBy(s => s.ToUpper());

D. var groups = list.GroupBy(s => s.Substring(1));

Solution

1. Step 1: Identify grouping key for first character

   Grouping by the first character means using s => s[0] as the key selector.

2. Step 2: Check other options

   Grouping by length, uppercase string, or substring starting at index 1 does not group by first character.

3. Final Answer:

   var groups = list.GroupBy(s => s[0]); -> Option A

4. Quick Check:

   First char key = s[0] [OK]

Hint: Use s => s[0] to group by first character [OK]

Common Mistakes:

• Using substring starting at 1 instead of 0
• Grouping by string length instead of character
• Using ToUpper() changes case but not grouping key

3. What is the output of the following C# code?

var numbers = new[] {1, 2, 3, 4, 5, 6};
var groups = numbers.GroupBy(n => n % 2 == 0 ? "Even" : "Odd");
foreach (var group in groups) {
    Console.WriteLine($"{group.Key}: {string.Join(",", group)}");
}

medium

A. 1: 1
2: 2
3: 3
4: 4
5: 5
6: 6

B. Even: 2,4,6
Odd: 1,3,5

C. Odd: 1,3,5
Even: 2,4,6

D. Even: 1,3,5
Odd: 2,4,6

Solution

1. Step 1: Understand grouping key logic

   Numbers are grouped by whether they are even or odd using the key "Even" or "Odd".

2. Step 2: Determine group contents and order

   Group "Odd" contains 1,3,5; group "Even" contains 2,4,6. The foreach prints groups in order they appear, which is "Odd" then "Even".

3. Final Answer:

   Odd: 1,3,5 Even: 2,4,6 -> Option C

4. Quick Check:

   Group keys "Odd" then "Even" with correct items [OK]

Hint: GroupBy preserves order of first occurrence of keys [OK]

Common Mistakes:

• Assuming groups print in alphabetical order
• Mixing up even and odd groups
• Expecting separate groups for each number

4. Identify the error in this C# code that tries to group words by their length:

var words = new List<string> {"apple", "bat", "car", "dog"};
var groups = words.GroupBy(word => word.Length);
foreach (var group in groups)
    Console.WriteLine(group.Key + ": " + group.ToString());

medium

A. Using group.ToString() instead of joining group elements.

B. GroupBy cannot be used on List<string>.

C. Missing semicolon after GroupBy statement.

D. word.Length is not a valid key selector.

Solution

1. Step 1: Check GroupBy usage

   GroupBy on List<string> with word.Length is valid syntax and logic.

2. Step 2: Analyze output statement

   Using group.ToString() prints the type name, not the grouped items. We should join group elements to display them.

3. Final Answer:

   Using group.ToString() instead of joining group elements. -> Option A

4. Quick Check:

   Print grouped items by joining, not ToString() [OK]

Hint: Join group elements to print, not group.ToString() [OK]

Common Mistakes:

• Thinking GroupBy can't be used on lists
• Forgetting to join group elements for display
• Misunderstanding word.Length as key selector

5. Given a list of employees with properties Name and Department, how would you use GroupBy to create a dictionary where keys are departments and values are lists of employee names?

hard

A. var dict = employees.GroupBy(e => e.Name).ToDictionary(g => g.Key, g => g.Select(e => e.Department).ToList());

B. var dict = employees.ToDictionary(e => e.Department, e => e.Name);

C. var dict = employees.GroupBy(e => e.Department).ToList();

D. var dict = employees.GroupBy(e => e.Department).ToDictionary(g => g.Key, g => g.Select(e => e.Name).ToList());

Solution

1. Step 1: Group employees by Department

   Use GroupBy with key selector e => e.Department to group employees by their department.

2. Step 2: Convert groups to dictionary with employee names list

   Use ToDictionary with key as group.Key (department) and value as list of employee names using g.Select(e => e.Name).ToList().

3. Final Answer:

   var dict = employees.GroupBy(e => e.Department).ToDictionary(g => g.Key, g => g.Select(e => e.Name).ToList()); -> Option D

4. Quick Check:

   GroupBy + ToDictionary with Select names = correct [OK]

Hint: GroupBy then ToDictionary with Select for values list [OK]

Common Mistakes:

• Using ToDictionary directly without grouping
• Grouping by Name instead of Department
• Not converting grouped items to list of names