Join

In C#, LINQ provides a join-keyword. As with other query languages (such as SQL) joining matches every element in two collections based on some condition.

We use this keyword in a query expression (beginning with from). We create new data structures (projections) based on the contents of elements.

First example

We use the Join() extension method, and a join query expression. The Join() and GroupJoin() methods are best used indirectly, through the query syntax.

using System;
using System.Linq;

// Part 1: create array 1 and array 2.
var ints1 = new int[3];
ints1[0] = 4;
ints1[1] = 3;
ints1[2] = 0;

var ints2 = new int[3];
ints2[0] = 5;
ints2[1] = 4;
ints2[2] = 2;

{
    // Part 2: join with method call.
    var result = ints1.Join<int, int, int, int>(ints2,
             x => x + 1,
             y => y,
             (x, y) => x);

    // Display results.
    foreach (var r in result)
    {
        Console.WriteLine(r);
    }
}

{
    // Part 3: join with query expression.
    var result = from t in ints1
             join x in ints2 on (t + 1) equals x
             select t;

    // Display results.
    foreach (var r in result)
    {
        Console.WriteLine(r);
    }
}
4  (First loop)
3
4  (Second loop)
3

Example 2

This example program uses two classes for storing data. Join query syntax is basically the same as in SQL. Occasionally it is easier to develop logic in this style.

using System;
using System.Linq;

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

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

class Program
{
    static void Main()
    {
        // Step 1: example customers and orders.
        var customers = new Customer[]
        {
            new Customer{ID = 5, Name = "Sam"},
            new Customer{ID = 6, Name = "Dave"},
            new Customer{ID = 7, Name = "Julia"},
            new Customer{ID = 8, Name = "Sue"}
        };

        var orders = new Order[]
        {
            new Order{ID = 5, Product = "Book"},
            new Order{ID = 6, Product = "Game"},
            new Order{ID = 7, Product = "Computer"},
            new Order{ID = 8, Product = "Shirt"}
        };

        // Step 2: join on the ID properties.
        var query = from c in customers
                    join o in orders on c.ID equals o.ID
                    select new { c.Name, o.Product };

        // Step 3: display joined groups.
        foreach (var group in query)
        {
            Console.WriteLine("{0} bought {1}", group.Name, group.Product);
        }
    }
}
Sam bought Book
Dave bought Game
Julia bought Computer
Sue bought Shirt

Fluent syntax, join IDs

This example joins two arrays of elements on the ID property of each element. It uses Animal and Medication instances.

using System;
using System.Linq;

class Animal
{
    public int ID { get; set; }
    public string Breed { get; set; }
}

class Medication
{
    public int ID { get; set; }
    public string Type { get; set; }
}

class Program
{
    static void Main()
    {
        // Example animals in veterinarian office.
        var animals = new Animal[]
        {
            new Animal{ID = 0, Breed = "cat"},
            new Animal{ID = 10, Breed = "dog"}
        };

        // Example medications (prescriptions).
        var medications = new Medication[]
        {
            new Medication{ID = 10, Type = "antibiotic"},
            new Medication{ID = 0, Type = "sedative"},
            new Medication{ID = 0, Type = "antihistamine"}
        };

        // Use fluent join syntax on ID.
        var query = animals.Join(medications,
              a => a.ID,
              m => m.ID,
              (a, m) => new { a.Breed, m.Type });

        // Results.
        foreach (var group in query)
        {
            Console.WriteLine($"{group.Breed} prescribed {group.Type}");
        }
    }
}
cat prescribed sedative
cat prescribed antihistamine
dog prescribed antibiotic

GroupJoin

Join is different from GroupJoin. With Join, we cannot create a new type to store multiple results together in a single element.

String.Join

The join-keyword in LINQ is not related to the string.Join method, which combines an array or List of strings into one string. Thread.Join is also a different thing.

Notes, internals

The join-query is translated to the Join() extension method. You can read how query expressions are translated in the chapter on Expressions (7) in the C# specification.

Using the LINQ extensions in the C# language, we can implement join expressions. This can make some matching routines more concise in a program.