Join and GroupJoin operations in C Sharp (C#) - Mini Project: Build & Apply

Join and GroupJoin operations

📖 Scenario: You work in a company that manages orders and customers. You have two lists: one with customers and one with orders. You want to connect orders to their customers to see who bought what.

🎯 Goal: Build a C# program that uses Join and GroupJoin operations to link customers with their orders and display the results.

📋 What You'll Learn

Create a list of customers with exact IDs and names

Create a list of orders with exact OrderIDs and CustomerIDs

Use Join to find matching orders and customers

Use GroupJoin to group orders by customer

Print the joined and grouped results exactly as specified

💡 Why This Matters

🌍 Real World

Joining and grouping data is common in business apps to connect related information like customers and their orders.

💼 Career

Understanding Join and GroupJoin helps you work with databases, reports, and data analysis in many programming jobs.

1

Create the customers and orders lists

Create a list called customers with these exact entries: new Customer { CustomerID = 1, Name = "Alice" }, new Customer { CustomerID = 2, Name = "Bob" }, new Customer { CustomerID = 3, Name = "Charlie" }. Also create a list called orders with these exact entries: new Order { OrderID = 101, CustomerID = 1 }, new Order { OrderID = 102, CustomerID = 2 }, new Order { OrderID = 103, CustomerID = 1 }, new Order { OrderID = 104, CustomerID = 3 }.

C Sharp (C#)

using System;
using System.Collections.Generic;

record Customer(int CustomerID, string Name);
record Order(int OrderID, int CustomerID);

class Program
{
    static void Main()
    {
        // Create customers and orders lists
        // Your code here
    }
}

Hint

Use var customers = new List { ... }; and var orders = new List { ... }; with the exact entries.

2

Create a join query to match orders with customers

Create a variable called orderCustomerJoin that uses Join on orders and customers to match orders to customers by CustomerID. Select a new object with OrderID and CustomerName from the matching pairs.

C Sharp (C#)

using System;
using System.Collections.Generic;

record Customer(int CustomerID, string Name);
record Order(int OrderID, int CustomerID);

class Program
{
    static void Main()
    {
        var customers = new List
        {
            new Customer(1, "Alice"),
            new Customer(2, "Bob"),
            new Customer(3, "Charlie")
        };

        var orders = new List
        {
            new Order(101, 1),
            new Order(102, 2),
            new Order(103, 1),
            new Order(104, 3)
        };

        // Create orderCustomerJoin using Join
        // Your code here
    }
}

Hint

Use orders.Join(customers, order => order.CustomerID, customer => customer.CustomerID, (order, customer) => new { order.OrderID, CustomerName = customer.Name }).

3

Create a group join query to group orders by customer

Create a variable called customerOrdersGroup that uses GroupJoin on customers and orders to group orders by each customer using CustomerID. Select a new object with CustomerName and Orders (the grouped orders).

C Sharp (C#)

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

record Customer(int CustomerID, string Name);
record Order(int OrderID, int CustomerID);

class Program
{
    static void Main()
    {
        var customers = new List
        {
            new Customer(1, "Alice"),
            new Customer(2, "Bob"),
            new Customer(3, "Charlie")
        };

        var orders = new List
        {
            new Order(101, 1),
            new Order(102, 2),
            new Order(103, 1),
            new Order(104, 3)
        };

        var orderCustomerJoin = orders.Join(
            customers,
            order => order.CustomerID,
            customer => customer.CustomerID,
            (order, customer) => new { order.OrderID, CustomerName = customer.Name }
        );

        // Create customerOrdersGroup using GroupJoin
        // Your code here
    }
}

Hint

Use customers.GroupJoin(orders, customer => customer.CustomerID, order => order.CustomerID, (customer, ordersGroup) => new { CustomerName = customer.Name, Orders = ordersGroup }).

4

Print the join and group join results

Print the results of orderCustomerJoin by showing each OrderID and CustomerName on separate lines in the format: Order {OrderID} belongs to {CustomerName}. Then print the results of customerOrdersGroup by showing each CustomerName and their orders on separate lines in the format: {CustomerName} has orders: {comma separated OrderIDs}. If a customer has no orders, print {CustomerName} has orders: None.

C Sharp (C#)

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

record Customer(int CustomerID, string Name);
record Order(int OrderID, int CustomerID);

class Program
{
    static void Main()
    {
        var customers = new List
        {
            new Customer(1, "Alice"),
            new Customer(2, "Bob"),
            new Customer(3, "Charlie")
        };

        var orders = new List
        {
            new Order(101, 1),
            new Order(102, 2),
            new Order(103, 1),
            new Order(104, 3)
        };

        var orderCustomerJoin = orders.Join(
            customers,
            order => order.CustomerID,
            customer => customer.CustomerID,
            (order, customer) => new { order.OrderID, CustomerName = customer.Name }
        );

        var customerOrdersGroup = customers.GroupJoin(
            orders,
            customer => customer.CustomerID,
            order => order.CustomerID,
            (customer, ordersGroup) => new { CustomerName = customer.Name, Orders = ordersGroup }
        );

        // Print the join and group join results
        // Your code here
    }
}

Hint

Use foreach loops to print each joined item and each grouped item. Use string.Join to list order IDs or print "None" if no orders.

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