Linq GroupInto Selector - linq

Question

I am coding through the MS 101 Linq examples, and the joins are throwing me for a loop ;)
Example 104 is intended to show how slightly more complex group joins work:
var prodByCategory =
from cat in categories
join prod in products on cat equals prod.Category into ps
from p in ps // <-- ?
select new { Category = cat, p.ProductName };
The part with the "?" confuses me because it looks like p is exactly the same thing as ps, and that clause is not in the earlier examples.
So I tried to write it using method/linq syntax and what I put together looks like this:
var prodByCategory = categories.GroupJoin(products, c => c, p => p.Category, (c, p) => new { Category = c, p.First().ProductName });
The call to First() confuses me because it is not in the earlier query expression.
When I run this I get an error because p is empty before it gets to first. I'm not sure how that is possible because the category list definitely matches up with the categories in the products collection.
foreach (var item in prodByCategory)
{
Console.WriteLine(item.ProductName + ": " + item.Category);
}
Products already have a category field. So what good is the query? I guess it's just a learning thing, but I'm having trouble understanding the value here (although that might be because I don't understand how the two collections get related).
Update:
Played around with Gert's suggestion. See his well-articulated explanation below. After a minor clean-up this worked:
var prodByCategory = categories.GroupJoin(products, cat => cat, prod => prod.Category,
(cat, prod) => new { cat, products })
.SelectMany(x => x.products
, (x, p) =>
new
{
Category = x.cat, // x.cat.CategoryName not accessible here
ProductName = p.ProductName
});

Answer 1

You are right that it looks pretty useless. GroupJoin (or join - into) is used to execute a hybrid of joining and grouping. The items at the right side of the join are grouped within the items at the left. So, this query in comprehensive syntax
from cat in Categories
join prod in Products on cat equals prod.Category into products
select new { Category = cat.CategoryName,
Products = products.Select (p => p.ProductName) }
with its fluent syntax equvalent
Categories.GroupJoin(Products, cat => cat, prod => prod.Category,
(cat, products => new
{
Category = cat.CategoryName,
Products = products.Select (p => p.ProductName)
})
results in
Beverages Chai
Chang
Guaraná Fantástica
Sasquatch Ale
...
Condiments Aniseed Syrup
Chef Anton's Cajun Seasoning
Chef Anton's Gumbo Mix
Grandma's Boysenberry Spread
...
The benefit of GroupJoin vs. Join is that a Category can have an empty collection of Products, which in SQL is analogous to an outer join.
The effect of join - into followed by from is that the grouped structure is flattened out again. So
from cat in Categories
join prod in Products on cat equals prod.Category into ps
from p in ps
select new { Category = cat.CategoryName, p.ProductName }
with its equivalent
Categories.GroupJoin(Products, cat => cat, prod => prod.Category,
(cat, products) => new {cat, products})
.SelectMany(x => x.products
, (x, p) =>
new
{
Category = x.cat.CategoryName,
ProductName = p.ProductName
})
produces
Category ProductName
--------------- ----------------------------------------
Beverages Chai
Beverages Chang
Condiments Aniseed Syrup
Condiments Chef Anton's Cajun Seasoning
Condiments Chef Anton's Gumbo Mix
Condiments Grandma's Boysenberry Spread
Produce Uncle Bob's Organic Dried Pears
Condiments Northwoods Cranberry Sauce
Meat/Poultry Mishi Kobe Niku
...
Which would be the same as using a simple join to start with.
So the part from p in ps looks like it shouldn't essentially change the query. But it's a disguised SelectMany! That's quite an essential change for such an innocent little statement. I'm not chained to fluent syntax, but sometimes "comprehensive" syntax conceals what really happens, which is an excellent way to produce bugs.

Answer 2

I believe your translation to fluent syntax is not correct. It should be:
var prodByCategory = categories.GroupJoin(products, c => c, p => p.Category, (c, p) => new { c = c, p = p })
.SelectMany (ps => ps.p, (ps, p) => new { Category = ps.c, ProductName = p.ProductName });
I would suggest using LinqPad to examine both the fluent syntax translations and the generated SQL of your LINQ statements. It is a great tool and I find myself using it often.
I agree that their use of that sample is questionable.