Lesson 22/31

Tutorials LINQ Mastery

Inner Join: The standard match

On this page

Merging Data Streams

Join allows you to correlate two sequences based on matching keys. It's the most common way to rebuild related data in your application.

1. How Join Works

A Join takes an outer sequence, an inner sequence, and key selectors for both. It then yields a combined result for every match found. **Performance Note:** LINQ Join internally uses a Hash Join algorithm, making it extremely fast (O(N+M)) compared to nested loops.


var query = students.Join(
    grades,
    student => student.Id,   // Outer key
    grade => grade.StudentId, // Inner key
    (student, grade) => new { student.Name, grade.Score } // Result
);
        

2. Join vs Where/SelectMany

In many cases, you can achieve the same result using SelectMany or a Where clause. However, Join is more performant because it uses a hash table for the lookup instead of a full scan for every outer element.

3. Architect Insight

Q: "Should I join in C# or in the Database?"

Architect Answer: "Join in the **Database** (IQueryable) whenever possible. This allows the DB engine to optimize the join using its indexes and only send the final combined result over the network. Only join in C# if you are merging data from two completely different sources (e.g., a SQL table and a JSON API response)."

LINQ Mastery
Course syllabus
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
Toolliyo Assistant
Ask about tutorials, ebooks, training, pricing, mentor services, and support. I use public site content only—not admin or internal tools.

care@toolliyo.com

Need callback? Share your details