LINQ Mastery
Lesson 23 of 31 74% of course

GroupJoin: Creating hierarchical results

18 · 8 min · 5/23/2026

Sign in to track progress and bookmarks.

The One-to-Many Join

Standard Join gives you a flat list. GroupJoin gives you a hierarchical list, where each outer item is paired with a collection of its matching inner items.

1. Hierarchy Pattern

Think of a list of Departments and its Employees. A GroupJoin will give you a sequence where each Department object contains a list of its Employees. This is exactly how we usually think about data in the real world.


var query = departments.GroupJoin(
    employees,
    dept => dept.Id,
    emp => emp.DeptId,
    (dept, empGroup) => new {
        DepartmentName = dept.Name,
        Staff = empGroup // staff is an IEnumerable<Employee>
    }
);
    

2. Relationship with SQL

In SQL, there is no direct equivalent to GroupJoin because SQL only returns flat sets. EF Core translates this into a LEFT OUTER JOIN and then reshapes the data into objects on the client side.

3. Architect Insight

Q: "When should I use GroupJoin instead of GroupBy?"

Architect Answer: "Use **GroupJoin** if you already have two separate lists. Use **GroupBy** if you have ONE list that you want to split into categories. GroupJoin is essentially a 'Join then GroupBy' in one high-performance operation."

Test your knowledge

Quizzes linked to this course—pass to earn certificates.

Browse all quizzes
LINQ Mastery

On this page

1. Hierarchy Pattern 2. Relationship with SQL 3. Architect Insight
General
Introduction to LINQ Mastery
1. Core Foundations
LINQ Fundamentals: Why LINQ? IQueryable vs IEnumerable: The Architect's choice Expression Trees: The power behind LINQ providers Method Syntax vs Query Syntax: Trade-offs
2. Filtering & Transformation
Where & Select: The bread and butter SelectMany: Flattening complex hierarchies OfType vs Cast: Handling heterogeneous collections Distinct & DistinctBy: Mastering unique sets
3. Aggregation & Quantifiers
Any, All, Contains: The boolean quantifiers Count, LongCount, Sum: Basic aggregations Min, Max, Average: Statistical operations Aggregate: The 'Fold' function of .NET
4. Ordering & Partitioning
OrderBy & OrderByDescending: Sorting data ThenBy: Multi-level sorting Take & Skip: Pagination strategies TakeWhile & SkipWhile: Dynamic partitioning
5. Sets & Lookups
Union, Intersect, Except: Set theory in C# Zip: Combining two streams ToDictionary vs ToLookup: One-to-One vs One-to-Many Chunk: Slicing data for batch processing
6. Join & Grouping
Inner Join: The standard match GroupJoin: Creating hierarchical results GroupBy: The SQL counterpart in LINQ Left Outer Join: The manual workaround in LINQ
7. Advanced Providers & Parallelism
PLINQ (Parallel LINQ): Speeding up CPU-bound queries AsParallel vs AsSequential: When to switch LINQ to XML: Processing documents with ease Custom LINQ Providers: How to build your own 'Queryable'
8. Real-world Performance & Patterns
Memory Leaks in LINQ: Capturing variables and closures Architect Case Study: Optimizing a multi-join dashboard query