Queryable.Join<TOuter, TInner, TKey, TResult> Method (IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter, TKey>>, Expression<Func<TInner, TKey>>, Expression<Func<TOuter, TInner, TResult>>)

I'm pertty new to LINQ myself, I've only started using it for the last 3 or 4 days, but even I can tell that the example provided isn't very good. That's because the Pet object itself has a reference to the Person object. So you could do the same thing without the Join() function by changing the foreach loop to:

foreach (Pet pet in pets)
{
    Console.WriteLine("{0} - {1}", pet.Owner.Name, pet.Name);
}

That is much better than using the Join() method: it's both easier to read and would run faster. However, real world applications aren't usually like that. For instance, if you were getting this data from a relational database, the Pet wouldn't have a direct reference to the Person, but both Pet and Person would instead have IDs (or primary keys) that would be used to identify them and there would be a relation from the Pet table to the Person table using those IDs. So here's a more realistic scenario that better demonstrates the beneficial aspects of the Join() function:

    class Person
    {
        public int PersonID { get; set; }
        public string Name { get; set; }
    }
    class Pet
    {
        public int PetID { get; set; }
        public string Name { get; set; }
        public int OwnerID { get; set; }
    }
    public static void JoinEx1()
    {
        List<Person> people = new List<Person>();
        List<Pet> pets = new List<Pet>();
        people.Add(new Person { PersonID = 1, Name = "Hedlund, Magnus" });
        people.Add(new Person { PersonID = 2, Name = "Adams, Terry" });
        people.Add(new Person { PersonID = 3, Name = "Weiss, Charlotte" });
        pets.Add(new Pet { PetID = 1, Name = "Barley", OwnerID = 2 });
        pets.Add(new Pet { PetID = 2, Name = "Boots", OwnerID = 2 });
        pets.Add(new Pet { PetID = 3, Name = "Whiskers", OwnerID = 3 });
        pets.Add(new Pet { PetID = 4, Name = "Daisy", OwnerID = 1 });
        // Join the list of Person objects and the list of Pet objects 
        // to create a list of person-pet pairs where each element is 
        // an anonymous type that contains the name of pet and the name
        // of the person that owns the pet.
        var query = people.AsQueryable().Join(pets,
                        person => person.PersonID,
                        pet => pet.OwnerID,
                        (person, pet) =>
                        new { OwnerName = person.Name, PetName = pet.Name });
        foreach (var obj in query)
        {
            Console.WriteLine("{0} - {1}", obj.OwnerName, obj.PetName);
        }
    }
    /*
        This code produces the following output:

        Hedlund, Magnus - Daisy
        Adams, Terry - Barley
        Adams, Terry - Boots
        Weiss, Charlotte - Whiskers
    */

As you can see, the Pet object doesn't have a direct reference to the Person object, instead it contains the numeric ID of the Person (called OwnerID in Pet and PersonID in Person). Join() takes that numeric ID and uses it to create a new list of objects that contain the associated names we are looking for. There is now no obviously simpler or better way to perform the same task without the Join() function. If we removed the join function, we would have to do something like this:

    	foreach (Person owner in people)
        {
            foreach (Pet pet in pets)
            {
                if (pet.OwnerID == owner.PersonID) 
                {
                    Console.WriteLine("{0} - {1}", owner.Name, pet.Name);
                }
            }
        }

Now that isn't really all that bad in this case. We're only going through a total of 12 iterations. But again, in the real world, you're usually dealing with much more than 3 people and 4 pets. Also, if this were being used against something like LINQ to SQL, which if I understand correctly would actually cause the join operation to be executed on the database server rather than on the client, then the performance advantage of the Join() function rather than iterating through some in memory collections of records is HUGE.

Anyways, I'm off to learn more about the coolness of LINQ (to SQL). I hope this proves helpful to someone. ;)