Enumerable.GroupBy 方法

定义

命名空间:: System.Linq

程序集:: System.Core.dll, System.Linq.dll

程序集:: netstandard.dll, System.Linq.dll

程序集:: System.Linq.dll

程序集:: System.Core.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

对序列的元素进行分组。

重载

名称	说明
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。每个组的元素是使用指定的函数投影的。
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。使用指定的比较器比较键值，并且每个组的元素都通过使用指定的函数进行投影。
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	根据指定的键选择器函数对序列的元素进行分组，并使用指定的函数投影每个组的元素。
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	根据键选择器函数对序列的元素进行分组。通过使用比较器比较键，并且每个组的元素都通过使用指定的函数进行投影。
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。使用指定的比较器比较键。
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	根据指定的键选择器函数对序列的元素进行分组。
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	根据指定的键选择器函数对序列的元素进行分组，并使用指定的比较器比较键。

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。每个组的元素是使用指定的函数投影的。

public:
generic <typename TSource, typename TKey, typename TElement, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TSource, TElement> ^ elementSelector, Func<TKey, System::Collections::Generic::IEnumerable<TElement> ^, TResult> ^ resultSelector);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TElement,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector, Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> * Func<'Key, seq<'Element>, 'Result> -> seq<'Result>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TElement, TResult) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), elementSelector As Func(Of TSource, TElement), resultSelector As Func(Of TKey, IEnumerable(Of TElement), TResult)) As IEnumerable(Of TResult)

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TElement

每个 IGrouping<TKey,TElement>元素的类型。

TResult

返回 resultSelector的结果值的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

elementSelector: Func<TSource,TElement>

一个函数，用于将每个源元素映射到一个 IGrouping<TKey,TElement>. 中的元素。

resultSelector: Func<TKey,IEnumerable<TElement>,TResult>

一个函数，用于从每个组创建结果值。

IEnumerable<TResult>

类型 TResult 元素的集合，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 或 elementSelector 为 resultSelectornull。

示例

下面的代码示例演示如何用于 GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) 对序列的投影元素进行分组，然后投影类型 TResult的结果序列。

class Pet
{
    public string Name { get; set; }
    public double Age { get; set; }
}

public static void GroupByEx4()
{
    // Create a list of pets.
    List<Pet> petsList =
        new List<Pet>{ new Pet { Name="Barley", Age=8.3 },
                       new Pet { Name="Boots", Age=4.9 },
                       new Pet { Name="Whiskers", Age=1.5 },
                       new Pet { Name="Daisy", Age=4.3 } };

    // Group Pet.Age values by the Math.Floor of the age.
    // Then project an anonymous type from each group
    // that consists of the key, the count of the group's
    // elements, and the minimum and maximum age in the group.
    var query = petsList.GroupBy(
        pet => Math.Floor(pet.Age),
        pet => pet.Age,
        (baseAge, ages) => new
        {
            Key = baseAge,
            Count = ages.Count(),
            Min = ages.Min(),
            Max = ages.Max()
        });

    // Iterate over each anonymous type.
    foreach (var result in query)
    {
        Console.WriteLine("\nAge group: " + result.Key);
        Console.WriteLine("Number of pets in this age group: " + result.Count);
        Console.WriteLine("Minimum age: " + result.Min);
        Console.WriteLine("Maximum age: " + result.Max);
    }

    /*  This code produces the following output:

        Age group: 8
        Number of pets in this age group: 1
        Minimum age: 8.3
        Maximum age: 8.3

        Age group: 4
        Number of pets in this age group: 2
        Minimum age: 4.3
        Maximum age: 4.9

        Age group: 1
        Number of pets in this age group: 1
        Minimum age: 1.5
        Maximum age: 1.5
    */
}

Structure Pet
    Public Name As String
    Public Age As Double
End Structure

Public Sub GroupByEx4()
    ' Create a list of pets.
    Dim petsList As New List(Of Pet)(New Pet() _
                         {New Pet With {.Name = "Barley", .Age = 8.3},
                          New Pet With {.Name = "Boots", .Age = 4.9},
                          New Pet With {.Name = "Whiskers", .Age = 1.5},
                          New Pet With {.Name = "Daisy", .Age = 4.3}})

    ' Group Pet.Age values by the Math.Floor of the age.
    ' Then project an anonymous type from each group
    ' that consists of the key, the count of the group's
    ' elements, and the minimum and maximum age in the group.
    Dim query = petsList.GroupBy(
Function(pet) Math.Floor(pet.Age),
Function(pet) pet.Age,
Function(baseAge, ages) New With
    {.Key = baseAge,
    .Count = ages.Count(),
    .Min = ages.Min(),
    .Max = ages.Max()}
)

    Dim output As New System.Text.StringBuilder
    ' Iterate over each anonymous type.
    For Each result In query
        output.AppendLine(vbCrLf & "Age group: " & result.Key)
        output.AppendLine("Number of pets in this age group: " & result.Count)
        output.AppendLine("Minimum age: " & result.Min)
        output.AppendLine("Maximum age: " & result.Max)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString)
End Sub

' This code produces the following output:

' Age group: 8
' Number of pets in this age group: 1
' Minimum age: 8.3
' Maximum age: 8.3
'
' Age group: 4
' Number of pets in this age group: 2
' Minimum age: 4.3
' Maximum age: 4.9
'
' Age group: 1
' Number of pets in this age group: 1
' Minimum age: 1.5
' Maximum age: 1.5

注解

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。

另请参阅

适用于

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。使用指定的比较器比较键值，并且每个组的元素都通过使用指定的函数进行投影。

public:
generic <typename TSource, typename TKey, typename TElement, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TSource, TElement> ^ elementSelector, Func<TKey, System::Collections::Generic::IEnumerable<TElement> ^, TResult> ^ resultSelector, System::Collections::Generic::IEqualityComparer<TKey> ^ comparer);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TElement,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector, Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TElement,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector, Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> * Func<'Key, seq<'Element>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TElement, TResult) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), elementSelector As Func(Of TSource, TElement), resultSelector As Func(Of TKey, IEnumerable(Of TElement), TResult), comparer As IEqualityComparer(Of TKey)) As IEnumerable(Of TResult)

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TElement

每个 IGrouping<TKey,TElement>元素的类型。

TResult

返回 resultSelector的结果值的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

elementSelector: Func<TSource,TElement>

一个函数，用于将每个源元素映射到一个 IGrouping<TKey,TElement>. 中的元素。

resultSelector: Func<TKey,IEnumerable<TElement>,TResult>

一个函数，用于从每个组创建结果值。

comparer: IEqualityComparer<TKey>

与键进行比较的一个 IEqualityComparer<T> 。

IEnumerable<TResult>

类型 TResult 元素的集合，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 或 elementSelector 为 resultSelectornull。

另请参阅

适用于

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并使用指定的函数投影每个组的元素。

public:
generic <typename TSource, typename TKey, typename TElement>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<System::Linq::IGrouping<TKey, TElement> ^> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TSource, TElement> ^ elementSelector);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>> GroupBy<TSource,TKey,TElement>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> -> seq<System.Linq.IGrouping<'Key, 'Element>>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TElement) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), elementSelector As Func(Of TSource, TElement)) As IEnumerable(Of IGrouping(Of TKey, TElement))

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TElement

中 IGrouping<TKey,TElement>元素的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

elementSelector: Func<TSource,TElement>

一个函数，用于将每个源元素映射到 . 中的 IGrouping<TKey,TElement>元素。

IEnumerable<IGrouping<TKey,TElement>>

C# 中的 IEnumerable<IGrouping<TKey, TElement>> 或 IEnumerable(Of IGrouping(Of TKey, TElement)) Visual Basic，其中每个 IGrouping<TKey,TElement> 对象包含类型为 TElement 和键的对象集合。

例外

ArgumentNullException

source 或 keySelector 为 elementSelectornull.

示例

下面的代码示例演示如何用于 GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) 对序列的元素进行分组。

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Uses method-based query syntax.
public static void GroupByEx1()
{
    // Create a list of pets.
    List<Pet> pets =
        new List<Pet>{ new Pet { Name="Barley", Age=8 },
                       new Pet { Name="Boots", Age=4 },
                       new Pet { Name="Whiskers", Age=1 },
                       new Pet { Name="Daisy", Age=4 } };

    // Group the pets using Age as the key value
    // and selecting only the pet's Name for each value.
    IEnumerable<IGrouping<int, string>> query =
        pets.GroupBy(pet => pet.Age, pet => pet.Name);

    // Iterate over each IGrouping in the collection.
    foreach (IGrouping<int, string> petGroup in query)
    {
        // Print the key value of the IGrouping.
        Console.WriteLine(petGroup.Key);
        // Iterate over each value in the
        // IGrouping and print the value.
        foreach (string name in petGroup)
            Console.WriteLine("  {0}", name);
    }
}

/*
 This code produces the following output:

 8
   Barley
 4
   Boots
   Daisy
 1
   Whiskers
*/

Structure Pet
    Public Name As String
    Public Age As Integer
End Structure

Sub GroupByEx1()
    'Create a list of Pet objects.
    Dim pets As New List(Of Pet)(New Pet() _
                         {New Pet With {.Name = "Barley", .Age = 8},
                          New Pet With {.Name = "Boots", .Age = 4},
                          New Pet With {.Name = "Whiskers", .Age = 1},
                          New Pet With {.Name = "Daisy", .Age = 4}})

    ' Group the pets using Age as the key
    ' and selecting only the pet's Name for each value.
    Dim query As IEnumerable(Of IGrouping(Of Integer, String)) =
pets.GroupBy(Function(pet) pet.Age,
             Function(pet) pet.Name)

    Dim output As New System.Text.StringBuilder
    ' Iterate over each IGrouping in the collection.
    For Each petGroup As IGrouping(Of Integer, String) In query
        ' Print the key value of the IGrouping.
        output.AppendLine(petGroup.Key)
        ' Iterate over each value in the IGrouping and print the value.
        For Each name As String In petGroup
            output.AppendLine("  " & name)
        Next
    Next

    ' Display the output.
    Console.WriteLine(output.ToString)
End Sub

' This code produces the following output:
'
' 8
'   Barley
' 4
'   Boots
'   Daisy
' 1
'   Whiskers

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。以下示例中查询表达式的转换等效于上述示例中的查询。

IEnumerable<IGrouping<int, string>> query =
    from pet in pets
    group pet.Name by pet.Age;

    Dim query =
From pet In pets
Group pet.Name By Age = pet.Age Into ageGroup = Group

注释

在 C# 或Visual Basic查询表达式中，元素和键选择表达式在调用 GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) 方法时按参数位置的相反顺序发生。

注解

此方法是使用延迟执行实现的。即时返回值是一个对象，用于存储执行操作所需的所有信息。除非通过直接调用其 GetEnumerator 方法或在 C# 中使用 foreach 或在 Visual Basic 中使用 For Each 来枚举对象，否则不会执行此方法表示的查询。

该方法 GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) 返回对象集合 IGrouping<TKey,TElement> ，其中一个对象用于遇到的每个非重复键。 An IGrouping<TKey,TElement> 是一个 IEnumerable<T> 也具有与其元素关联的键。

根据IGrouping<TKey,TElement>生成每个source元素的第一个键的元素IGrouping<TKey,TElement>的顺序生成对象。分组中的元素按生成元素的顺序生成。source

默认相等比较器 Default 用于比较键。

另请参阅

适用于

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据键选择器函数对序列的元素进行分组。通过使用比较器比较键，并且每个组的元素都通过使用指定的函数进行投影。

public:
generic <typename TSource, typename TKey, typename TElement>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<System::Linq::IGrouping<TKey, TElement> ^> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TSource, TElement> ^ elementSelector, System::Collections::Generic::IEqualityComparer<TKey> ^ comparer);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>> GroupBy<TSource,TKey,TElement>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>> GroupBy<TSource,TKey,TElement>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<System.Linq.IGrouping<'Key, 'Element>>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TElement) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), elementSelector As Func(Of TSource, TElement), comparer As IEqualityComparer(Of TKey)) As IEnumerable(Of IGrouping(Of TKey, TElement))

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TElement

中 IGrouping<TKey,TElement>元素的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

elementSelector: Func<TSource,TElement>

一个函数，用于将每个源元素映射到一个 IGrouping<TKey,TElement>. 中的元素。

comparer: IEqualityComparer<TKey>

要比较键的一个 IEqualityComparer<T> 。

IEnumerable<IGrouping<TKey,TElement>>

例外

ArgumentNullException

source 或 keySelector 为 elementSelectornull.

注解

注释

有关示例 GroupBy，请参阅以下文章：

该方法 GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) 返回对象集合 IGrouping<TKey,TElement> ，其中一个对象用于遇到的每个非重复键。 An IGrouping<TKey,TElement> 是一个 IEnumerable<T> 也具有与其元素关联的键。

根据IGrouping<TKey,TElement>生成每个source元素的第一个键的元素IGrouping<TKey,TElement>的顺序生成对象。分组中的元素按生成元素的顺序生成。source

comparer如果是null，则默认相等比较器Default用于比较键。

如果两个键被视为相等 comparer，则选择第一个键作为该分组的密钥。

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。有关详细信息和用法示例，请参阅 group 子句和 Group By 子句。

另请参阅

适用于

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。

public:
generic <typename TSource, typename TKey, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TKey, System::Collections::Generic::IEnumerable<TSource> ^, TResult> ^ resultSelector);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Key, seq<'Source>, 'Result> -> seq<'Result>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TResult) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult)) As IEnumerable(Of TResult)

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TResult

返回 resultSelector的结果值的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

resultSelector: Func<TKey,IEnumerable<TSource>,TResult>

一个函数，用于从每个组创建结果值。

IEnumerable<TResult>

类型 TResult 元素的集合，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 为 resultSelectornull.

示例

下面的代码示例演示如何用于 GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) 对序列的元素进行分组，并投影一系列类型 TResult的结果。

class Pet
{
    public string Name { get; set; }
    public double Age { get; set; }
}

public static void GroupByEx3()
{
    // Create a list of pets.
    List<Pet> petsList =
        new List<Pet>{ new Pet { Name="Barley", Age=8.3 },
                       new Pet { Name="Boots", Age=4.9 },
                       new Pet { Name="Whiskers", Age=1.5 },
                       new Pet { Name="Daisy", Age=4.3 } };

    // Group Pet objects by the Math.Floor of their age.
    // Then project an anonymous type from each group
    // that consists of the key, the count of the group's
    // elements, and the minimum and maximum age in the group.
    var query = petsList.GroupBy(
        pet => Math.Floor(pet.Age),
        (age, pets) => new
        {
            Key = age,
            Count = pets.Count(),
            Min = pets.Min(pet => pet.Age),
            Max = pets.Max(pet => pet.Age)
        });

    // Iterate over each anonymous type.
    foreach (var result in query)
    {
        Console.WriteLine("\nAge group: " + result.Key);
        Console.WriteLine("Number of pets in this age group: " + result.Count);
        Console.WriteLine("Minimum age: " + result.Min);
        Console.WriteLine("Maximum age: " + result.Max);
    }

    /*  This code produces the following output:

        Age group: 8
        Number of pets in this age group: 1
        Minimum age: 8.3
        Maximum age: 8.3

        Age group: 4
        Number of pets in this age group: 2
        Minimum age: 4.3
        Maximum age: 4.9

        Age group: 1
        Number of pets in this age group: 1
        Minimum age: 1.5
        Maximum age: 1.5
    */
}

Structure Pet
    Public Name As String
    Public Age As Double
End Structure

Public Sub GroupByEx3()
    ' Create a list of pets.
    Dim petsList As New List(Of Pet)(New Pet() _
                         {New Pet With {.Name = "Barley", .Age = 8.3},
                          New Pet With {.Name = "Boots", .Age = 4.9},
                          New Pet With {.Name = "Whiskers", .Age = 1.5},
                          New Pet With {.Name = "Daisy", .Age = 4.3}})

    ' Group Pet objects by the Math.Floor of their age.
    ' Then project an anonymous type from each group
    ' that consists of the key, the count of the group's
    ' elements, and the minimum and maximum age in the group.
    Dim query = petsList.GroupBy(
Function(pet) Math.Floor(pet.Age),
Function(age, pets) New With
    {.Key = age,
    .Count = pets.Count(),
    .Min = pets.Min(Function(pet) pet.Age),
    .Max = pets.Max(Function(Pet) Pet.Age)}
)

    Dim output As New System.Text.StringBuilder
    ' Iterate over each anonymous type.
    For Each result In query
        output.AppendLine(vbCrLf & "Age group: " & result.Key)
        output.AppendLine("Number of pets in this age group: " & result.Count)
        output.AppendLine("Minimum age: " & result.Min)
        output.AppendLine("Maximum age: " & result.Max)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString)
End Sub

' This code produces the following output:

' Age group: 8
' Number of pets in this age group: 1
' Minimum age: 8.3
' Maximum age: 8.3
'
' Age group: 4
' Number of pets in this age group: 2
' Minimum age: 4.3
' Maximum age: 4.9
'
' Age group: 1
' Number of pets in this age group: 1
' Minimum age: 1.5
' Maximum age: 1.5

注解

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。

另请参阅

适用于

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。使用指定的比较器比较键。

public:
generic <typename TSource, typename TKey, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, Func<TKey, System::Collections::Generic::IEnumerable<TSource> ^, TResult> ^ resultSelector, System::Collections::Generic::IEqualityComparer<TKey> ^ comparer);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);

public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Key, seq<'Source>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>

<Extension()>
Public Function GroupBy(Of TSource, TKey, TResult) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult), comparer As IEqualityComparer(Of TKey)) As IEnumerable(Of TResult)

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

TResult

返回 resultSelector的结果值的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

resultSelector: Func<TKey,IEnumerable<TSource>,TResult>

一个函数，用于从每个组创建结果值。

comparer: IEqualityComparer<TKey>

与键进行比较的一个 IEqualityComparer<T> 。

IEnumerable<TResult>

类型 TResult 元素的集合，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 为 resultSelectornull.

另请参阅

适用于

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组。

public:
generic <typename TSource, typename TKey>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<System::Linq::IGrouping<TKey, TSource> ^> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> -> seq<System.Linq.IGrouping<'Key, 'Source>>

<Extension()>
Public Function GroupBy(Of TSource, TKey) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey)) As IEnumerable(Of IGrouping(Of TKey, TSource))

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

IEnumerable<IGrouping<TKey,TSource>>

C# 或 IEnumerable<IGrouping<TKey, TSource>> Visual Basic 中的一个IEnumerable(Of IGrouping(Of TKey, TSource))对象，其中每个IGrouping<TKey,TElement>对象都包含一系列对象和一个键。

例外

ArgumentNullException

source 或 keySelector 为 null.

注解

注释

有关示例 GroupBy，请参阅以下文章：

该方法 GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) 返回对象集合 IGrouping<TKey,TElement> ，其中一个对象用于遇到的每个非重复键。 An IGrouping<TKey,TElement> 是一个 IEnumerable<T> 也具有与其元素关联的键。

根据IGrouping<TKey,TElement>生成每个source元素的第一个键的元素IGrouping<TKey,TElement>的顺序生成对象。分组中的元素按它们出现 source的顺序生成。

默认相等比较器 Default 用于比较键。

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。有关详细信息和用法示例，请参阅 group 子句和 Group By 子句。

另请参阅

适用于

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

Source:: Grouping.cs

根据指定的键选择器函数对序列的元素进行分组，并使用指定的比较器比较键。

public:
generic <typename TSource, typename TKey>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<System::Linq::IGrouping<TKey, TSource> ^> ^ GroupBy(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, System::Collections::Generic::IEqualityComparer<TKey> ^ comparer);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer);

static member GroupBy : seq<'Source> * Func<'Source, 'Key> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<System.Linq.IGrouping<'Key, 'Source>>

<Extension()>
Public Function GroupBy(Of TSource, TKey) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), comparer As IEqualityComparer(Of TKey)) As IEnumerable(Of IGrouping(Of TKey, TSource))

类型参数

TSource

的元素 source的类型。

TKey

返回 keySelector的键的类型。

参数

source: IEnumerable<TSource>

IEnumerable<T>要分组的元素。

keySelector: Func<TSource,TKey>

用于提取每个元素的键的函数。

comparer: IEqualityComparer<TKey>

要比较键的一个 IEqualityComparer<T> 。

IEnumerable<IGrouping<TKey,TSource>>

C# 中的 IEnumerable<IGrouping<TKey, TSource>> 或 Visual Basic 中的 IEnumerable(Of IGrouping(Of TKey, TSource))，其中每个 IGrouping<TKey,TElement> 对象包含对象和键的集合。

例外

ArgumentNullException

source 或 keySelector 为 null.

注解

注释

有关示例 GroupBy，请参阅以下文章：

该方法 GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) 返回对象集合 IGrouping<TKey,TElement> ，其中一个对象用于遇到的每个非重复键。 An IGrouping<TKey,TElement> 是一个 IEnumerable<T> 也具有与其元素关联的键。

根据IGrouping<TKey,TElement>生成每个source元素的第一个键的元素IGrouping<TKey,TElement>的顺序生成对象。分组中的元素按它们出现 source的顺序生成。

comparer如果是null，则默认相等比较器Default用于比较键。

如果两个键被视为相等 comparer，则选择第一个键作为该分组的密钥。

在查询表达式语法中，group by （C#）或 Group By Into （Visual Basic）子句转换为调用 GroupBy。有关详细信息和用法示例，请参阅 group 子句和 Group By 子句。

另请参阅

适用于

反馈

此页面是否有帮助？