C# GroupJoin

GroupJoin is an extension method. It groups one collection of objects by a key and joins those groups with another collection of keyed objects. With this method from the System.Linq namespace, we create a collection where, at each key, a group of results is placed.

This C# program demonstrates the GroupJoin extension method. It requires System.Linq.

Example

The GroupJoin method is challenging to use correctly. It requires at least four arguments: you must specify the secondary collection, as the first argument. For the second argument, you need a Func that returns the key from the first object type. For the third argument, you need a Func that returns the key from the second object type. For the fourth argument, you need a Func that stores the grouped object with the group itself.

We can specify these Func types with the lambda expression syntax. In this example, we use regular classes; it is probably more common to use anonymous types. We can finally loop over the resulting collection with the foreach loop construct.

Program that uses GroupJoin method [C#]

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

class Customer
{
    public int Code { get; set; }
    public string Name { get; set; }
}

class Order
{
    public int KeyCode { get; set; }
    public string Product { get; set; }
}

class Result
{
    public string Name { get; set; }
    public IEnumerable<Order> Collection { get; set; }
    public Result(string name, IEnumerable<Order> collection)
    {
	this.Name = name;
	this.Collection = collection;
    }
}

class Program
{
    static void Main()
    {
	// Example customers.
	var customers = new Customer[]
	{
	    new Customer{Code = 5, Name = "Sam"},
	    new Customer{Code = 6, Name = "Dave"},
	    new Customer{Code = 7, Name = "Julia"},
	    new Customer{Code = 8, Name = "Sue"}
	};

	// Example orders.
	var orders = new Order[]
	{
	    new Order{KeyCode = 5, Product = "Book"},
	    new Order{KeyCode = 6, Product = "Game"},
	    new Order{KeyCode = 7, Product = "Computer"},
	    new Order{KeyCode = 7, Product = "Mouse"},
	    new Order{KeyCode = 8, Product = "Shirt"},
	    new Order{KeyCode = 5, Product = "Underwear"}
	};

	// Correlate "customers" with "orders"
	// ... Use Code property as key for Customer.
	// ... Use KeyCode property as key for Order.
	// ... For each result, create object with Name and IEnumerable of orders.
	var query = customers.GroupJoin(orders,
	    c => c.Code,
	    o => o.KeyCode,
	    (c, result) => new Result(c.Name, result));

	// Enumerate results.
	foreach (var result in query)
	{
	    Console.WriteLine("{0} bought...", result.Name);
	    foreach (var item in result.Collection)
	    {
		Console.WriteLine(item.Product);
	    }
	}
    }
}

Output

Sam bought...
Book
Underwear
Dave bought...
Game
Julia bought...
Computer
Mouse
Sue bought...
Shirt

Opinion

The GroupJoin method is probably more effort to use than it is worth. It would be possible to create a similar implementation using an object model. You could use a Dictionary, put objects as the keys of the Dictionary, while implementing IEqualityComparer.

Next, you could use the List type to store the individual objects on each value in the Dictionary. Methods could be added to find those objects or determine their existence. This solution would be imperative in nature, but would use the performance advantages of Dictionary to their fullest, while avoiding any performance drawbacks of the Func type of the GroupJoin method itself.

Summary

With GroupJoin, we can group objects from one collection with any number of objects with from another collection. Though the method is challenging to use, as it receives three different Func implementations, it can be helpful when you need to create a grouped collection but do not want to write imperative code, as with the Dictionary type.