Queryable.GroupBy 方法

定义

命名空间:

System.Linq

程序集:

System.Linq.Queryable.dll

对序列中的元素进行分组。

重载

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

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

Source:

Queryable.cs

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

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

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

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TElement

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

TResult

resultSelector 返回的结果值的类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

elementSelector

Expression<Func<TSource,TElement>>

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

resultSelector

Expression<Func<TKey,IEnumerable<TElement>,TResult>>

用于从每个组中创建结果值的函数。

comparer

IEqualityComparer<TKey>

用于比较键的 IEqualityComparer<T>。

返回

IQueryable<TResult>

一 T:System.Linq.IQueryable`1 个 ，其类型参数 TResult 为 ，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 或 elementSelector 或 resultSelector 或 comparer 为 null。

注解

此方法至少有一个类型 Expression<TDelegate> 参数，其类型参数是类型之 Func<T,TResult> 一。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>, IEqualityComparer<TKey>) 生成一个 ， MethodCallExpression 它将调用 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>, IEqualityComparer<TKey>) 自身表示为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>, IEqualityComparer<TKey>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它按通过调用keySelector每个元素source获得的键值对 的元素进行分组。 参数 comparer 用于比较键值。 参数 elementSelector 用于投影每个组的元素，而 resultSelector 参数用于从每个组及其键获取结果值。

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

Source:

Queryable.cs

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

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

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

static member GroupBy : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, 'Key>> * System.Linq.Expressions.Expression<Func<'Source, 'Element>> * System.Linq.Expressions.Expression<Func<'Key, seq<'Element>, 'Result>> -> System.Linq.IQueryable<'Result>

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TElement

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

TResult

resultSelector 返回的结果值的类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

elementSelector

Expression<Func<TSource,TElement>>

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

resultSelector

Expression<Func<TKey,IEnumerable<TElement>,TResult>>

用于从每个组中创建结果值的函数。

返回

IQueryable<TResult>

一 T:System.Linq.IQueryable`1 个 ，其类型参数 TResult 为 ，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 或 elementSelector 或 resultSelector 为 null。

示例

下面的代码示例演示如何使用 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<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.AsQueryable().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

Shared 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 valuesby 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.AsQueryable().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 with this age: " & result.Count)
        output.AppendLine("Minimum age: " & result.Min)
        output.AppendLine("Maximum age: " & result.Max)
    Next

    ' Display the output.
    MsgBox(output.ToString())

    ' This code produces the following output:

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

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

    '  Age group: 1
    '  Number of pets with this age: 1
    '  Minimum age: 1.5
    '  Maximum age: 1.5
End Sub

注解

此方法至少有一个类型 Expression<TDelegate> 参数，其类型参数是类型之 Func<T,TResult> 一。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>) 生成一个 ， MethodCallExpression 它将调用 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>) 自身表示为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey, IEnumerable<TElement>,TResult>>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它按通过调用keySelector每个元素source获得的键值对 的元素进行分组。 参数 elementSelector 用于投影每个组的元素，而 resultSelector 参数用于从每个组及其键获取结果值。

GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>)

Source:

Queryable.cs

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

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

public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TElement>> GroupBy<TSource,TKey,TElement> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TKey>> keySelector, System.Linq.Expressions.Expression<Func<TSource,TElement>> elementSelector);

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TElement

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

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

elementSelector

Expression<Func<TSource,TElement>>

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

返回

IQueryable<IGrouping<TKey,TElement>>

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

例外

ArgumentNullException

source、keySelector 或 elementSelector 为 null。

示例

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

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

public static void GroupByEx2()
{
    // Create a list of Pet objects.
    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 Pet.Age as the key.
    // Use Pet.Name as the value for each entry.
    IEnumerable<IGrouping<int, string>> query =
        pets.AsQueryable().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

Shared Sub GroupByEx2()
    ' 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 Pet.Age as the key.
    ' Use Pet.Name as the value for each entry.
    Dim query As IEnumerable(Of IGrouping(Of Integer, String)) = _
        pets.AsQueryable().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(String.Format("  {0}", name))
        Next
    Next

    ' Display the output.
    MsgBox(output.ToString())
End Sub

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

注解

此方法至少有一个类型 Expression<TDelegate> 参数，其类型参数是类型之 Func<T,TResult> 一。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>) 生成一个 ， MethodCallExpression 它将调用 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>) 自身表示为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它按通过调用keySelector每个元素source获取的键值对 的元素进行分组。 它对每个元素调用 elementSelector 以获取结果元素。

GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>)

Source:

Queryable.cs

对序列中的元素进行分组并且通过使用指定的函数对每组中的元素进行投影。 通过使用指定的比较器对键值进行比较。

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

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

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TElement

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

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

elementSelector

Expression<Func<TSource,TElement>>

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

comparer

IEqualityComparer<TKey>

用于比较键的 IEqualityComparer<T>。

返回

IQueryable<IGrouping<TKey,TElement>>

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

例外

ArgumentNullException

source 或 keySelector 或 elementSelector 或 comparer 为 null。

注解

此方法至少有一个类型 Expression<TDelegate> 参数，其类型参数是类型之 Func<T,TResult> 一。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) 生成一个 ， MethodCallExpression 它将调用 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) 自身表示为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它按通过调用keySelector每个元素source获取的键值对 的元素进行分组。 使用 comparer比较键值。 elementSelector对每个元素调用 参数以获取结果元素。

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

Source:

Queryable.cs

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

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

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

static member GroupBy : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, 'Key>> * System.Linq.Expressions.Expression<Func<'Key, seq<'Source>, 'Result>> -> System.Linq.IQueryable<'Result>

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TResult

resultSelector 返回的结果值的类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

resultSelector

Expression<Func<TKey,IEnumerable<TSource>,TResult>>

用于从每个组中创建结果值的函数。

返回

IQueryable<TResult>

一 T:System.Linq.IQueryable`1 个 ，其类型参数为 TResult ，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source、keySelector 或 resultSelector 为 null。

示例

下面的代码示例演示如何使用 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<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.AsQueryable().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

Shared 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.AsQueryable().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 with this age: " & result.Count)
        output.AppendLine("Minimum age: " & result.Min)
        output.AppendLine("Maximum age: " & result.Max)
    Next

    ' Display the output.
    MsgBox(output.ToString())

    ' This code produces the following output:

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

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

    '  Age group: 1
    '  Number of pets with this age: 1
    '  Minimum age: 1.5
    '  Maximum age: 1.5
End Sub

注解

此方法至少有一个类型的 Expression<TDelegate> 参数，其类型参数是其中一种 Func<T,TResult> 类型。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>) 生成一个 ， MethodCallExpression 表示将调用 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>) 自身作为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它通过调用keySelector每个元素source获取的键值对 的元素进行分组。 参数 resultSelector 用于从每个组及其键获取结果值。

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

Source:

Queryable.cs

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

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

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

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

TResult

resultSelector 返回的结果值的类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

resultSelector

Expression<Func<TKey,IEnumerable<TSource>,TResult>>

用于从每个组中创建结果值的函数。

comparer

IEqualityComparer<TKey>

用于比较键的 IEqualityComparer<T>。

返回

IQueryable<TResult>

一 T:System.Linq.IQueryable`1 个 ，其类型参数为 TResult ，其中每个元素表示对组及其键的投影。

例外

ArgumentNullException

source 或 keySelector 或 resultSelector 或 comparer 为 null。

注解

此方法至少有一个类型的 Expression<TDelegate> 参数，其类型参数是其中一种 Func<T,TResult> 类型。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>) 生成一个 ， MethodCallExpression 表示将调用 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>) 自身作为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它按通过调用keySelector每个元素source获取的键值对 的元素进行分组。 参数 comparer 用于比较键， resultSelector 参数用于从每个组及其键获取结果值。

GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)

Source:

Queryable.cs

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

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

public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TKey>> keySelector);

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

返回

IQueryable<IGrouping<TKey,TSource>>

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

例外

ArgumentNullException

source 或 keySelector 为 null。

示例

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

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

public static void GroupByEx1()
{
    // Create a list of Pet objects.
    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 Pet.Age as the key.
    // Use Pet.Name as the value for each entry.
    var query = pets.AsQueryable().GroupBy(pet => pet.Age);

    // Iterate over each IGrouping in the collection.
    foreach (var ageGroup in query)
    {
        Console.WriteLine("Age group: {0}  Number of pets: {1}", ageGroup.Key, ageGroup.Count());
    }
}

/*
    This code produces the following output:

    Age group: 8  Number of pets: 1
    Age group: 4  Number of pets: 2
    Age group: 1  Number of pets: 1

*/

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

Shared 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 Pet.Age as the key.
    ' Use Pet.Name as the value for each entry.
    Dim query = pets.AsQueryable().GroupBy(Function(pet) pet.Age)

    Dim output As New System.Text.StringBuilder
    ' Iterate over each IGrouping in the collection.
    For Each ageGroup In query
        output.AppendFormat("Age group: {0}   Number of pets: {1}{2}", ageGroup.Key, ageGroup.Count(), vbCrLf)
    Next

    ' Display the output.
    MsgBox(output.ToString())
End Sub

' This code produces the following output:
'
' Age group: 8   Number of pets: 1
' Age group: 4   Number of pets: 2
' Age group: 1   Number of pets: 1

注解

此方法至少有一个类型的 Expression<TDelegate> 参数，其类型参数是其中一种 Func<T,TResult> 类型。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) 生成一个 ， MethodCallExpression 表示将调用 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) 自身作为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期行为是，它通过调用keySelector每个元素source获取的键值对 的元素进行分组。

GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)

Source:

Queryable.cs

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

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

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

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

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

类型参数

TSource

source 的元素类型。

TKey

由 keySelector 表示的函数返回的键类型。

参数

source

IQueryable<TSource>

要对其元素进行分组的 IQueryable<T>。

keySelector

Expression<Func<TSource,TKey>>

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

comparer

IEqualityComparer<TKey>

用于比较键的 IEqualityComparer<T>。

返回

IQueryable<IGrouping<TKey,TSource>>

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

例外

ArgumentNullException

source、keySelector 或 comparer 为 null。

注解

此方法至少有一个类型的 Expression<TDelegate> 参数，其类型参数是其中一种 Func<T,TResult> 类型。 对于这些参数，可以传入 lambda 表达式，它将编译为 Expression<TDelegate>。

方法 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>) 生成一个 ， MethodCallExpression 表示将调用 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>) 自身作为构造的泛型方法。 然后，MethodCallExpressionCreateQuery<TElement>(Expression)它将 传递给 由 Provider 参数的 属性表示的 的 source 方法IQueryProvider。

由于执行表示调用 GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>) 的表达式树而发生的查询行为取决于参数类型的 source 实现。 预期的行为是，它按键值对 的 source 元素进行分组。 通过调用 keySelector 每个元素来获取键值，并使用 comparer比较键值。