Compartir vía

Agrupar elementos en una secuencia

El GroupBy operador agrupa los elementos de una secuencia. En los ejemplos siguientes se usa la base de datos Northwind.

Nota:

A veces, los valores de columna NULL en las consultas GroupBy pueden generar un InvalidOperationException. Para obtener más información, vea la sección "GroupBy InvalidOperationException" de Solución de problemas.

Ejemplo 1

El siguiente ejemplo particiona Products por CategoryID.

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

Ejemplo 2

En el ejemplo siguiente se usa Max para buscar el precio unitario máximo de cada CategoryID.

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)

Ejemplo 3

En el ejemplo siguiente se usa Average para buscar el promedio UnitPrice de cada CategoryID.

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)

Ejemplo 4

En el ejemplo siguiente se usa Sum para buscar el total UnitPrice de cada CategoryID.

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

Ejemplo 5

En el ejemplo siguiente se utiliza Count para buscar el número de Products que ya no se fabrican en cada CategoryID.

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

Ejemplo 6

En el ejemplo siguiente se usa una cláusula siguiente where para buscar todas las categorías que tienen al menos 10 productos.

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

Ejemplo 7

En el ejemplo siguiente se agrupan productos por CategoryID y SupplierID.

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

Ejemplo 8

En el ejemplo siguiente se devuelven dos secuencias de productos. La primera secuencia contiene productos con un precio unitario menor o igual que 10. La segunda secuencia contiene productos con un precio unitario superior a 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

Ejemplo

El GroupBy operador solo puede tomar un único argumento de clave. Si necesita agrupar por más de una clave, debe crear un tipo anónimo, como en el ejemplo siguiente:

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

Consulte también

  • Last updated on