Gruppieren von Elementen in einer Sequenz

Der GroupBy Operator gruppiert die Elemente einer Sequenz. In den folgenden Beispielen wird die Northwind-Datenbank verwendet.

Hinweis

NULL-Spaltenwerte in GroupBy-Abfragen können manchmal eine InvalidOperationException auslösen. Weitere Informationen finden Sie im Abschnitt "GroupBy InvalidOperationException" der Problembehandlung.

Beispiel 1

Im folgenden Beispiel wird Products durch CategoryID partitioniert.

IQueryable<IGrouping<Int32?, Product>> prodQuery =
    from prod in db.Products
    group prod by prod.CategoryID into grouping
    select grouping;

foreach (IGrouping<Int32?, Product> grp in prodQuery)
{
    Console.WriteLine($"\nCategoryID Key = {grp.Key}:");
    foreach (Product listing in grp)
    {
        Console.WriteLine($"\t{listing.ProductName}");
    }
}

Dim prodQuery = From prod In db.Products _
                Group prod By prod.CategoryID Into grouping = Group

For Each grp In prodQuery
    Console.WriteLine(vbNewLine & "CategoryID Key = {0}:", _
        grp.CategoryID)
    For Each listing In grp.grouping
        Console.WriteLine(vbTab & listing.ProductName)
    Next
Next

Beispiel 2

Im folgenden Beispiel wird anhand von Max der maximale Einzelpreis für jede CategoryID Einheit ermittelt.

var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new
    {
        g.Key,
        MaxPrice = g.Max(p => p.UnitPrice)
    };

Dim query = From p In db.Products _
            Group p By p.CategoryID Into g = Group _
            Select CategoryID, MaxPrice = g.Max(Function(p) p.UnitPrice)

Beispiel 3

Im folgenden Beispiel wird "Average" verwendet, um den Mittelwert UnitPrice für die einzelnen CategoryID zu ermitteln.

var q2 =
    from p in db.Products
    group p by p.CategoryID into g
    select new
    {
        g.Key,
        AveragePrice = g.Average(p => p.UnitPrice)
    };

Dim q2 = From p In db.Products _
         Group p By p.CategoryID Into g = Group _
         Select CategoryID, AveragePrice = g.Average(Function(p) _
        p.UnitPrice)

Beispiel 4

Im folgenden Beispiel wird Sum verwendet, um die gesamte UnitPrice für jedes CategoryID zu finden.

var priceQuery =
    from prod in db.Products
    group prod by prod.CategoryID into grouping
    select new
    {
        grouping.Key,
        TotalPrice = grouping.Sum(p => p.UnitPrice)
    };

foreach (var grp in priceQuery)
{
    Console.WriteLine("Category = {0}, Total price = {1}",
        grp.Key, grp.TotalPrice);
}

Dim priceQuery = From prod In db.Products _
                 Group prod By prod.CategoryID Into grouping = Group _
                 Select CategoryID, TotalPrice = grouping.Sum(Function(p) _
        p.UnitPrice)

For Each grp In priceQuery
    Console.WriteLine("Category = {0}, Total price = {1}", _
        grp.CategoryID, grp.TotalPrice)
Next

Beispiel 5

Im folgenden Beispiel wird Count verwendet, um die Anzahl eingestellter Products in jeder CategoryID zu ermitteln.

var disconQuery =
    from prod in db.Products
    group prod by prod.CategoryID into grouping
    select new
    {
        grouping.Key,
        NumProducts = grouping.Count(p => p.Discontinued)
    };

foreach (var prodObj in disconQuery)
{
    Console.WriteLine("CategoryID = {0}, Discontinued# = {1}",
        prodObj.Key, prodObj.NumProducts);
}

Dim disconQuery = From prod In db.Products _
                  Group prod By prod.CategoryID Into grouping = Group _
                  Select CategoryID, NumProducts = grouping.Count(Function(p) _
        p.Discontinued)

For Each prodObj In disconQuery
    Console.WriteLine("CategoryID = {0}, Discontinued# = {1}", _
        prodObj.CategoryID, prodObj.NumProducts)
Next

Beispiel 6

Im folgenden Beispiel wird eine folgende where Klausel verwendet, um alle Kategorien mit mindestens 10 Produkten zu finden.

var prodCountQuery =
    from prod in db.Products
    group prod by prod.CategoryID into grouping
    where grouping.Count() >= 10
    select new
    {
        grouping.Key,
        ProductCount = grouping.Count()
    };

foreach (var prodCount in prodCountQuery)
{
    Console.WriteLine("CategoryID = {0}, Product count = {1}",
        prodCount.Key, prodCount.ProductCount);
}

Dim prodCountQuery = From prod In db.Products _
                     Group prod By prod.CategoryID Into grouping = Group _
                     Where grouping.Count >= 10 _
                     Select CategoryID, ProductCount = grouping.Count

For Each prodCount In prodCountQuery
    Console.WriteLine("CategoryID = {0}, Product count = {1}", _
        prodCount.CategoryID, prodCount.ProductCount)
Next

Beispiel 7

Im folgenden Beispiel werden Produkte nach CategoryID und SupplierID gruppiert.

var prodQuery =
    from prod in db.Products
    group prod by new
    {
        prod.CategoryID,
        prod.SupplierID
    }
    into grouping
    select new { grouping.Key, grouping };

foreach (var grp in prodQuery)
{
    Console.WriteLine("\nCategoryID {0}, SupplierID {1}",
        grp.Key.CategoryID, grp.Key.SupplierID);
    foreach (var listing in grp.grouping)
    {
        Console.WriteLine($"\t{listing.ProductName}");
    }
}

Dim prodQuery = From prod In db.Products _
                Group prod By Key = New With {prod.CategoryID, prod.SupplierID} _
                    Into grouping = Group

For Each grp In prodQuery
    Console.WriteLine(vbNewLine & "CategoryID {0}, SupplierID {1}", _
        grp.Key.CategoryID, grp.Key.SupplierID)
    For Each listing In grp.grouping
        Console.WriteLine(vbTab & listing.ProductName)
    Next
Next

Beispiel 8

Im folgenden Beispiel werden zwei Produktsequenzen zurückgegeben. Die erste Sequenz enthält Produkte mit Stückpreis kleiner oder gleich 10. Die zweite Sequenz enthält Produkte mit Stückpreis größer als 10.

var priceQuery =
    from prod in db.Products
    group prod by new
    {
        Criterion = prod.UnitPrice > 10
    }
    into grouping
    select grouping;

foreach (var prodObj in priceQuery)
{
    if (prodObj.Key.Criterion == false)
        Console.WriteLine("Prices 10 or less:");
    else
        Console.WriteLine("\nPrices greater than 10");
    foreach (var listing in prodObj)
    {
        Console.WriteLine("{0}, {1}", listing.ProductName,
            listing.UnitPrice);
    }
}

Dim priceQuery = From prod In db.Products _
                 Group prod By Key = New With {.Criterion = prod.UnitPrice > 10} _
                     Into grouping = Group Select Key, grouping

For Each prodObj In priceQuery
    If prodObj.Key.Criterion = False Then
        Console.WriteLine("Prices 10 or less:")
    Else
        Console.WriteLine("\nPrices greater than 10")
        For Each listing In prodObj.grouping
            Console.WriteLine("{0}, {1}", listing.ProductName, _
                listing.UnitPrice)
        Next
    End If
Next

Beispiel

Der GroupBy Operator kann nur ein einzelnes Schlüsselargument verwenden. Wenn Sie nach mehreren Schlüsseln gruppieren müssen, müssen Sie wie im folgenden Beispiel einen anonymen Typ erstellen:

var custRegionQuery =
    from cust in db.Customers
    group cust.ContactName by new { City = cust.City, Region = cust.Region };

foreach (var grp in custRegionQuery)
{
    Console.WriteLine($"\nLocation Key: {grp.Key}");
    foreach (var listing in grp)
    {
        Console.WriteLine($"\t{listing}");
    }
}

Dim custRegionQuery = From cust In db.Customers _
                      Group cust.ContactName By Key = New With _
                          {cust.City, cust.Region} Into grouping = Group

For Each grp In custRegionQuery
    Console.WriteLine(vbNewLine & "Location Key: {0}", grp.Key)
    For Each listing In grp.grouping
        Console.WriteLine(vbTab & "{0}", listing)
    Next
Next

Siehe auch

Last updated on 2025-06-20