Join and GroupJoin operations in C Sharp (C#)

Introduction

Join and GroupJoin help you combine two lists based on matching values. They make it easy to find related data from different sources.

You have two lists, like students and their grades, and want to match students with their grades.

You want to find all orders and the products in each order.

You need to combine employee data with their department info.

You want to group related items, like customers and their orders.

Syntax

C Sharp (C#)

var joinResult = list1.Join(
    list2,
    item1 => item1.Key,
    item2 => item2.Key,
    (item1, item2) => new { item1, item2 }
);

var groupJoinResult = list1.GroupJoin(
    list2,
    item1 => item1.Key,
    item2 => item2.Key,
    (item1, group) => new { item1, group }
);

Join matches items one-to-one based on keys.

GroupJoin matches one item to many related items as a group.

Examples

This joins students with their grades by matching student IDs.

C Sharp (C#)

var joinResult = students.Join(
    grades,
    student => student.Id,
    grade => grade.StudentId,
    (student, grade) => new { student.Name, grade.Score }
);

This groups all grades for each student.

C Sharp (C#)

var groupJoinResult = students.GroupJoin(
    grades,
    student => student.Id,
    grade => grade.StudentId,
    (student, gradesGroup) => new { student.Name, Grades = gradesGroup.Select(g => g.Score) }
);

Sample Program

This program shows how to use Join to pair each student with each of their grades, and GroupJoin to group all grades per student.

C Sharp (C#)

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

class Program
{
    public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    public class Grade
    {
        public int StudentId { get; set; }
        public int Score { get; set; }
    }

    static void Main()
    {
        var students = new List<Student>
        {
            new() { Id = 1, Name = "Alice" },
            new() { Id = 2, Name = "Bob" },
            new() { Id = 3, Name = "Charlie" }
        };

        var grades = new List<Grade>
        {
            new() { StudentId = 1, Score = 85 },
            new() { StudentId = 1, Score = 90 },
            new() { StudentId = 2, Score = 78 }
        };

        var joinResult = students.Join(
            grades,
            student => student.Id,
            grade => grade.StudentId,
            (student, grade) => new { student.Name, grade.Score }
        );

        Console.WriteLine("Join result (student and each grade):");
        foreach (var item in joinResult)
        {
            Console.WriteLine($"{item.Name} scored {item.Score}");
        }

        var groupJoinResult = students.GroupJoin(
            grades,
            student => student.Id,
            grade => grade.StudentId,
            (student, gradesGroup) => new { student.Name, Scores = gradesGroup.Select(g => g.Score) }
        );

        Console.WriteLine("\nGroupJoin result (student and all grades):");
        foreach (var item in groupJoinResult)
        {
            var scores = string.Join(", ", item.Scores);
            Console.WriteLine($"{item.Name} scored: {scores}");
        }
    }
}

Important Notes

If no matching items are found in Join, those items are skipped.

GroupJoin always includes all items from the first list, even if the group is empty.

Use GroupJoin when you want to keep all items from the first list and group related items from the second.

Summary

Join matches items one-to-one based on keys.

GroupJoin matches one item to many related items as a group.

Both help combine related data from two lists easily.

Practice

1.

What is the main difference between Join and GroupJoin in C# LINQ?

easy

A. Join matches one item to one item; GroupJoin matches one item to many items as a group.

B. Join is used only for numbers; GroupJoin is used only for strings.

C. Join creates groups; GroupJoin creates flat lists.

D. Join works only with arrays; GroupJoin works only with lists.

Solution

1. Step 1: Understand Join behavior

   Join pairs each item from the first list with exactly one matching item from the second list based on a key.

2. Step 2: Understand GroupJoin behavior

   GroupJoin pairs each item from the first list with a collection (group) of matching items from the second list.

3. Final Answer:

   Join matches one item to one item; GroupJoin matches one item to many items as a group. -> Option A

4. Quick Check:

   Join = one-to-one, GroupJoin = one-to-many [OK]

Hint: Remember: Join = pairs, GroupJoin = groups [OK]

Common Mistakes:

• Thinking Join creates groups
• Confusing GroupJoin with Join syntax
• Assuming Join works only with arrays

2.

Which of the following is the correct syntax to perform a Join operation in C# LINQ?

var result = from a in listA
             join b in listB on a.Id equals b.Id
             select new { a.Name, b.Value };

easy

A. var result = from a in listA join b in listB on a.Id == b.Id select new { a.Name, b.Value };

B. var result = from a in listA join b in listB where a.Id == b.Id select new { a.Name, b.Value };

C. var result = from a in listA join b in listB on a.Id equals b.Id select new { a.Name, b.Value };

D. var result = from a in listA join b in listB by a.Id equals b.Id select new { a.Name, b.Value };

Solution

1. Step 1: Check correct join syntax

   The correct syntax uses join b in listB on a.Id equals b.Id to specify the matching keys.

2. Step 2: Identify errors in other options

   var result = from a in listA join b in listB where a.Id == b.Id select new { a.Name, b.Value }; uses where instead of on ... equals, which is invalid for join. var result = from a in listA join b in listB by a.Id equals b.Id select new { a.Name, b.Value }; misplaces by. var result = from a in listA join b in listB on a.Id == b.Id select new { a.Name, b.Value }; uses == instead of equals.

3. Final Answer:

   var result = from a in listA join b in listB on a.Id equals b.Id select new { a.Name, b.Value }; -> Option C

4. Quick Check:

   Join syntax = on ... equals ... [OK]

Hint: Use 'on key1 equals key2' for Join syntax [OK]

Common Mistakes:

• Using '==' instead of 'equals' in join
• Replacing 'on' with 'where' in join
• Adding extra keywords like 'by'

3.

What is the output of the following C# code?

var students = new[] {
    new { Id = 1, Name = "Alice" },
    new { Id = 2, Name = "Bob" }
};
var scores = new[] {
    new { StudentId = 1, Score = 90 },
    new { StudentId = 1, Score = 85 },
    new { StudentId = 2, Score = 88 }
};

var query = students.GroupJoin(scores,
    s => s.Id,
    sc => sc.StudentId,
    (s, scGroup) => new {
        Student = s.Name,
        Scores = scGroup.Select(x => x.Score).ToList()
    });

foreach (var item in query) {
    Console.WriteLine($"{item.Student}: {string.Join(",", item.Scores)}");
}

medium

A. Alice: 90,85,88
Bob:

B. Alice: 90,85
Bob: 88

C. Alice: 90
Bob: 85,88

D. Alice:
Bob: 90,85,88

Solution

1. Step 1: Understand GroupJoin matching

   Each student is matched with all scores where StudentId equals Id. Alice (Id=1) matches scores 90 and 85; Bob (Id=2) matches score 88.

2. Step 2: Output formatting

   The code prints each student's name followed by their scores joined by commas. So output lines are "Alice: 90,85" and "Bob: 88".

3. Final Answer:

   Alice: 90,85 Bob: 88 -> Option B

4. Quick Check:

   GroupJoin groups scores by student [OK]

Hint: GroupJoin groups many matches per key [OK]

Common Mistakes:

• Assuming Join returns groups
• Mixing up StudentId and Id keys
• Printing scores incorrectly

4.

Identify the error in this C# LINQ GroupJoin code snippet:

var result = listA.GroupJoin(listB,
    a => a.Id,
    b => b.Id,
    (a, bGroup) => new {
        a.Name,
        bGroup
    });

medium

A. Cannot use bGroup directly without projection like ToList().

B. Missing select keyword before the new anonymous object.

C. The lambda parameters a and b must have the same name.

D. The GroupJoin method requires a third collection parameter.

Solution

1. Step 1: Check usage of bGroup in projection

   bGroup is an IEnumerable of matching items. It cannot be used directly in the anonymous type without materializing it (e.g., bGroup.ToList()) because it is lazily evaluated and multiple enumerations can lead to unexpected behavior or performance issues.

2. Step 2: Rule out other options

   No select keyword is needed--the lambda is the projection. Lambda parameters a and b can have different names. GroupJoin requires only two collections.

3. Final Answer:

   Cannot use bGroup directly without projection like ToList(). -> Option A

4. Quick Check:

   GroupJoin returns groups; project with ToList() for clarity [OK]

Hint: Always project groups to list for easier use [OK]

Common Mistakes:

• Thinking GroupJoin needs select keyword
• Assuming lambda parameter names must match
• Expecting extra collection parameter

5.

You have two lists: authors and books. Each book has an AuthorId. You want to create a list showing each author and all their book titles, but if an author has no books, show an empty list. Which LINQ operation is best?

hard

A. Use SelectMany to flatten authors and books.

B. Use Join to match authors and books.

C. Use Where to filter authors with books only.

D. Use GroupJoin to group books by author.

Solution

1. Step 1: Understand requirement for grouping

   You want each author with a collection of their books, including authors with no books (empty list).

2. Step 2: Choose correct LINQ operation

   GroupJoin creates a one-to-many relationship and includes authors with no matching books, producing empty groups as needed.

3. Final Answer:

   Use GroupJoin to group books by author. -> Option D

4. Quick Check:

   GroupJoin = one-to-many with empty groups included [OK]

Hint: GroupJoin keeps authors without books with empty groups [OK]

Common Mistakes:

• Using Join excludes authors without books
• Filtering authors removes those without books
• SelectMany flattens, losing grouping