在简单/未命名的 C# LINQ 组连接中排序内部密钥源

我知道这个问题由于用词不同而读起来很奇怪。但这是使用的术语这个 MSDN 页面 http://msdn.microsoft.com/en-us/library/bb311040.aspx从我正在学习 LINQ 组的地方开始，我将解释它们。

我正在尝试 LINQ 的数据是：

    class Product
    {
        public string Name { get; set; }
        public int CategoryID { get; set; }
    }

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

    // Specify the first data source.
    static List<Category> categories = new List<Category>()
    { 
        new Category(){Name="Beverages", ID=001},
        new Category(){ Name="Condiments", ID=002},
        new Category(){ Name="Vegetables", ID=003},
        new Category() {  Name="Grains", ID=004},
        new Category() {  Name="Fruit", ID=005}            
    };

    // Specify the second data source.
    static List<Product> products = new List<Product>()
    {
        new Product{Name="Cola",  CategoryID=001},
        new Product{Name="Tea",  CategoryID=001},
        new Product{Name="Mustard", CategoryID=002},
        new Product{Name="Pickles", CategoryID=002},
        new Product{Name="Carrots", CategoryID=003},
        new Product{Name="Bok Choy", CategoryID=003},
        new Product{Name="Peaches", CategoryID=005},
        new Product{Name="Melons", CategoryID=005},
    };

现在条款：

• 简单/未命名的组加入是我们直接选择组的一个：

  //... 
  join product in products on category.ID equals product.CategoryID into prodGroup                      
          select prodGroup;
  

  而不是选择匿名类型或使用嵌套from-select clause.

• 外部密钥源在 LINQ group join 中是一个数据源from关键词，内部密钥源是一个数据源，如下join keyword

  我称之为简单的群组加入unnamed（为了方便起见），因为我们在所选组中没有外部密钥源名称/Id。

我试图编写简单/未命名的查询，它将产生以下结果，首先按外部 keysource 属性排序，然后按内部 keysource 属性排序：

Unnamed Group
  Cola
  Tea
Unnamed Group
  Mustard
  Pickles
Unnamed Group
  Melons
  Peaches
Unnamed Group
Unnamed Group
  Bok Choy
  Carrots

我可以通过外部密钥源进行订购，如下所示：

var simpleGroupJoinOrderby = 
        from category in categories
        orderby category.Name           //orderby outer ks
        join product in products on category.ID equals product.CategoryID into prodGroup                      
        select prodGroup;

foreach (var unnamedGroup in simpleGroupJoinOrderby)
{   
    Console.WriteLine("Unnamed group");
    foreach(var product in unnamedGroup)
    {
        Console.WriteLine("  " + product.Name);
    }
}

但它产生以下输出：

Unnamed group
  Cola
  Tea
Unnamed group
  Mustard
  Pickles
Unnamed group
  Peaches
  Melons
Unnamed group
Unnamed group
  Carrots
  Bok Choy

但我无法订购未命名类别组下的产品。

我知道我可以通过选择匿名类型来做到这一点，如下所示：

        var namedGroupJoinOrderBy =
            from category in categories
            orderby category.Name  //order group hierarchy by name
            join product in products on category.ID equals product.CategoryID into prodGroup
            select
            new
            {
                Category = category.Name,
                Products = from prod in prodGroup
                           orderby prod.Name       //order by prodGroup.prod.Name under particular group hierarchy
                           select prod
            };

        foreach (var category in namedGroupJoinOrderBy)
        {
            Console.WriteLine("Category : " + category.Category);
            foreach (var product in category.Products)
            {
                Console.WriteLine("   " + product.Name);
            }
        }

但是我只是想知道我是否可以在不选择匿名类型的情况下执行相同的操作。我觉得它在语法上应该与“两个”关键源上的顺序和选择匿名类型无关。因此，应该有某种方法可以在查询本身中执行此操作，如下所示，但它不起作用：

var simpleGroupJoinOrderby = 
            from category in categories
            orderby category.Name           //orderby outer ks
            join product in products on category.ID equals product.CategoryID into prodGroup    
            orderby product.Name   //Err: The name 'product' does not exist in the current context
            select prodGroup;

你可以直接订购products加入前：

var simpleGroupJoinOrderby = 
    from category in categories
    orderby category.Name     
    join product in products.OrderBy(p => p.Name) 
        on category.ID equals product.CategoryID into prodGroup                      
    select prodGroup;

结果是：

Unnamed group
  Cola
  Tea
Unnamed group
  Mustard
  Pickles
Unnamed group
  Melons
  Peaches
Unnamed group
Unnamed group
  Bok Choy
  Carrots

它有效是因为Join保留了 external 元素的顺序，并且对于每个元素，inner 的匹配元素的顺序（引用自MSDN http://msdn.microsoft.com/en-us/library/bb534675.aspx).

一些替代方案（更像你的例子）：

var simpleGroupJoinOrderby = categories.OrderBy (c => c.Name)
                                       .GroupJoin(products, 
                                                  c => c.ID, 
                                                  p => p.CategoryID, 
                                                  (c, ps) => ps.OrderBy(p => p.Name));

var simpleGroupJoinOrderby = from category in categories
                             orderby category.Name     
                             join product in products
                                on category.ID equals product.CategoryID into prodGroup                      
                             select prodGroup.OrderBy(g => g.Name);