Aggregate, clause (Visual Basic)

Article
06/23/2023

Applique une ou plusieurs fonctions d’agrégation à une collection.

Syntaxe

Aggregate element [As type] In collection _  
  [, element2 [As type2] In collection2, [...]]  
  [ clause ]  
  Into expressionList

Éléments

Terme	Définition
`element`	Obligatoire. Variable utilisée pour itérer les éléments de la collection.
`type`	Optionnel. Type d'élément `element`. Si aucun type n’est spécifié, le type de `element` est déduit de `collection`.
`collection`	Obligatoire. Fait référence à la collection à utiliser.
`clause`	Optionnel. Une ou plusieurs clauses de requête, telles qu’une clause `Where`, pour affiner le résultat de la requête pour y appliquer la ou les clauses d’agrégation.
`expressionList`	Obligatoire. Une ou plusieurs expressions séparées par des virgules qui identifient une fonction d’agrégation à appliquer à la collection. Vous pouvez appliquer un alias à une fonction d’agrégation pour spécifier un nom de membre pour le résultat de la requête. Si aucun alias n’est fourni, le nom de la fonction d’agrégation est utilisé. Pour obtenir des exemples, consultez la section sur les fonctions d’agrégation plus loin dans cette rubrique.

Notes

La clause Aggregate peut être utilisée pour inclure des fonctions d’agrégation dans vos requêtes. Les fonctions d’agrégation effectuent des vérifications et des calculs sur un ensemble de valeurs et renvoient une valeur unique. Vous pouvez accéder à la valeur calculée en utilisant un membre du type de résultat de requête. Les fonctions d’agrégation standard que vous pouvez utiliser sont les fonctions All, Any, Average, Count, LongCount, Max, Min et Sum. Ces fonctions sont familières aux développeurs familiarisés avec les agrégats en SQL. Ils sont décrits dans la section suivante de cette rubrique.

Le résultat d’une fonction d’agrégation est inclus dans le résultat de la requête en tant que champ du type de résultat de la requête. Vous pouvez fournir un alias pour le résultat de la fonction d’agrégation afin de spécifier le nom du membre du type de résultat de la requête qui contiendra la valeur d’agrégation. Si aucun alias n’est fourni, le nom de la fonction d’agrégation est utilisé.

La clause Aggregate peut commencer une requête, ou elle peut être incluse en tant que clause supplémentaire dans une requête. Si la clause Aggregate commence une requête, le résultat est une valeur unique qui est le résultat de la fonction d’agrégation spécifiée dans la clause Into. Si plusieurs fonctions d’agrégation sont spécifiées dans la clause Into, la requête renvoie un seul type avec une propriété distincte pour référencer le résultat de chaque fonction d’agrégation dans la clause Into. Si la clause Aggregate est incluse en tant que clause supplémentaire dans une requête, le type renvoyé dans la collection de requêtes aura une propriété distincte pour référencer le résultat de chaque fonction d’agrégation dans la clause Into.

Fonctions d’agrégation

Voici les fonctions d’agrégation standard qui peuvent être utilisées avec la clause Aggregate.

Tous

Renvoie true si tous les éléments de la collection satisfont à une condition spécifiée ; sinon, renvoie false. Par exemple :

Dim customerList1 = Aggregate order In orders
                    Into AllOrdersOver100 = All(order.Total >= 100)

Quelconque

Renvoie true si un élément de la collection satisfait à une condition spécifiée ; sinon, renvoie false. Par exemple :

Dim customerList2 = From cust In customers
                    Aggregate order In cust.Orders
                    Into AnyOrderOver500 = Any(order.Total >= 500)

Moyenne

Calcule la moyenne de tous les éléments de la collection ou calcule une expression fournie pour tous les éléments de la collection. Par exemple :

Dim customerOrderAverage = Aggregate order In orders
                           Into Average(order.Total)

Count

Dim customerOrderAfter1996 = From cust In customers
                             Aggregate order In cust.Orders
                             Into Count(order.OrderDate > #12/31/1996#)

Groupe

Fait référence aux résultats de requête groupés à la suite d’une clause Group By ou Group Join. La fonction Group n’est valide que dans la clause Into d’une clause Group By ou Group Join. Pour plus d’informations et d’exemples, consultez Clause Group By et Clause Group Join.

LongCount

Compte le nombre d’éléments dans la collection. Vous pouvez fournir une expression Boolean facultative pour compter uniquement le nombre d’éléments de la collection qui satisfont à une condition. Renvoie le résultat sous la forme d’un Long. Pour un exemple, voir la fonction d’agrégation Count.

Max

Calcule la valeur maximale de la collection ou calcule une expression fournie pour tous les éléments de la collection. Par exemple :

Dim customerMaxOrder = Aggregate order In orders
                       Into MaxOrder = Max(order.Total)

Min

Calcule la valeur minimale de la collection ou calcule une expression fournie pour tous les éléments de la collection. Par exemple :

Dim customerMinOrder = From cust In customers
                       Aggregate order In cust.Orders
                       Into MinOrder = Min(order.Total)

Sum

Calcule la somme de tous les éléments de la collection ou calcule une expression fournie pour tous les éléments de la collection. Par exemple :

Dim customerTotals = From cust In customers
                     Aggregate order In cust.Orders
                     Into Sum(order.Total)

Exemple

L’exemple suivant montre comment utiliser la clause Aggregate pour appliquer des fonctions d’agrégation à un résultat de requête.

Public Sub AggregateSample()
    Dim customers = GetCustomerList()

    Dim customerOrderTotal =
        From cust In customers
        Aggregate order In cust.Orders
        Into Sum(order.Total), MaxOrder = Max(order.Total),
        MinOrder = Min(order.Total), Avg = Average(order.Total)

    For Each customer In customerOrderTotal
        Console.WriteLine(customer.cust.CompanyName & vbCrLf &
                         vbTab & "Sum = " & customer.Sum & vbCrLf &
                         vbTab & "Min = " & customer.MinOrder & vbCrLf &
                         vbTab & "Max = " & customer.MaxOrder & vbCrLf &
                         vbTab & "Avg = " & customer.Avg.ToString("#.##"))
    Next
End Sub

Création de fonctions d’agrégation définies par un utilisateur

Vous pouvez inclure vos propres fonctions d’agrégation personnalisées dans une expression de requête en ajoutant des méthodes d’extension au type IEnumerable<T>. Votre méthode personnalisée peut ensuite effectuer un calcul ou une opération sur la collection énumérable qui a référencé votre fonction d’agrégation. Pour plus d’informations sur les méthodes d’extension, consultez Méthodes d’extension.

Par exemple, l’exemple suivant montre une fonction d’agrégation personnalisée qui calcule la valeur médiane d’une collection de nombres. Il existe deux surcharges de la méthode d’extension Median. La première surcharge accepte, en entrée, une collection de type IEnumerable(Of Double). Si la fonction d’agrégation Median est appelée pour un champ de requête de type Double, cette méthode sera appelée. La seconde surcharge de la méthode Median peut être transmise à n’importe quel type générique. La surcharge générique de la méthode Median utilise un deuxième paramètre qui fait référence à l’expression lambda Func(Of T, Double) pour projeter une valeur pour un type (à partir d’une collection) comme valeur correspondante de type Double. Cela délègue ensuite le calcul de la valeur médiane à l’autre surcharge de la méthode Median. Pour plus d’informations sur les expressions lambda, consultez Expressions Lambda.

Imports System.Runtime.CompilerServices

Module UserDefinedAggregates

    ' Calculate the median value for a collection of type Double.
    <Extension()>
    Function Median(ByVal values As IEnumerable(Of Double)) As Double
        If values.Count = 0 Then
            Throw New InvalidOperationException("Cannot compute median for an empty set.")
        End If

        Dim sortedList = From number In values
                         Order By number

        Dim medianValue As Double

        Dim itemIndex = CInt(Int(sortedList.Count / 2))

        If sortedList.Count Mod 2 = 0 Then
            ' Even number of items in list.
            medianValue = ((sortedList(itemIndex) + sortedList(itemIndex - 1)) / 2)
        Else
            ' Odd number of items in list.
            medianValue = sortedList(itemIndex)
        End If

        Return medianValue
    End Function

    ' "Cast" the collection of generic items as type Double and call the 
    ' Median() method to calculate the median value.
    <Extension()>
    Function Median(Of T)(ByVal values As IEnumerable(Of T),
                          ByVal selector As Func(Of T, Double)) As Double
        Return (From element In values Select selector(element)).Median()
    End Function

End Module

L’exemple suivant montre des exemples de requêtes qui appellent la fonction d’agrégation Median sur une collection de type Integer et une collection de type Double. La requête qui appelle la fonction d’agrégation Median sur la collection de type Double appelle la surcharge de la méthode Median qui accepte en entrée une collection de type Double. La requête qui appelle la fonction d’agrégation Median sur la collection de type Integer appelle la surcharge générique de la méthode Median.

Module Module1

    Sub Main()
        Dim numbers1 = {1, 2, 3, 4, 5}

        Dim query1 = Aggregate num In numbers1 Into Median(num)

        Console.WriteLine("Median = " & query1)

        Dim numbers2 = {1.9, 2, 8, 4, 5.7, 6, 7.2, 0}

        Dim query2 = Aggregate num In numbers2 Into Median()

        Console.WriteLine("Median = " & query2)
    End Sub

End Module

Partager via