Understanding the GroupJoin and Join in Linq chaining syntax (Homework)

Question

I need help with understanding the fourth argument for GroupJoin. From what i understand so far GroupJoin takes 4 arguments: (1, 2) - the first one is the secondary list and argument two is a Func that returns the key from the first object type in other words from the first list in this case (people). (3, 4) A Func that returns the key from the second object type from the second list in this case (items), and one that stores the grouped object with the group itself (I can't understand the code for this part). Considering this and having the code below:

var products = new Product[]
{
    new Product { Id = 1, Type = "Phone", Model = "OnePlus", Price = 1000 },
    new Product { Id = 2, Type = "Phone", Model = "Apple", Price = 2000 },
    new Product { Id = 3, Type = "Phone", Model = "Samsung", Price = 1500 },
    new Product { Id = 4, Type = "TV", Model = "Samsung 32", Price = 200 },
};

var people = new Person[]
{
    new Person { Id = 1, Name = "Ivan Ivanov", Money = 150000 },
    new Person { Id = 2, Name = "Dragan Draganov", Money = 250000 },
    new Person { Id = 3, Name = "Ivelin Ivelinov", Money = 350000 
}
};

var items = new Item[]
{
    new Item { PersonId = 1, ProductId = 1, Amount = 1 },
    new Item { PersonId = 1, ProductId = 4, Amount = 1 },
    new Item { PersonId = 1, ProductId = 5, Amount = 1 },
    new Item { PersonId = 1, ProductId = 7, Amount = 1 },
    new Item { PersonId = 2, ProductId = 2, Amount = 1 },
};

Query:

var productOwnerList = people
    .GroupJoin(
        items,
        o => o.Id,
        i => i.PersonId,
        (o, i) => new   <--- (**)            
        {
            Person = o,
            Products = i
                .Join(products,
                    o1 => o1.ProductId,
                    i2 => i2.Id,
                 (o1, i2) => i2)          <--- (*)
                .ToArray()
        })
    .ToArray();  

Just to mention I post only a few lines for the data. I need help to understand what the 4th argument for the join method is performing here -> (*) (stores the grouped object with the group itself) ? When i watch the result i see it it puts all Person id's associate with the product keys and joined the two lists based on Items list (one to many). But i cannot get what exactly this line means (o1, o2) => i2). Its obvious what is doing (put all the items associated with the person id in a array (items[]) for every person. but what is "under the hood" here ? Also one question about (**) this line its creating new object, is this a anonymous class or if its not what is it.

Answer 1

The fourth argument - which maps to the fifth parameter in the documentation (because the first parameter is the target of the extension method call) is just the result selector. It's a function accepting two parameters: the first is an element of the "outer" sequence (the people array in your case) and the second is a sequence of elements from the "inner" sequence (the items array in your case) which have the same key as the outer element. The function should return a "result" element, and the overall result of the method call is a sequence of those results.

The function is called once for each of the "outer" elements, so you'd have:

• First call: person ID 1, and products with IDs 1, 4, 5, 7
• Second call: person ID 2, and the product with ID 2
• Third call: person ID 3, and an empty sequence of products

Your query is complex because you're using an anonymous type for your result, and constructing an instance of the anonymous type using another query. Here's a simpler query that might help to clarify:

var productOwnerList = people
    .GroupJoin(
        items,
        o => o.Id,
        i => i.PersonId,
        (person, items) => $"{person.Id}: {string.Join(",", items.Select(item => item.ProductId))}"
    .ToArray();