Aggregate, clause (Visual Basic)

Article
06/23/2022
7 minutes de lecture

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 au sein des éléments de la collection.
`type`	facultatif. Type d'élément `element`. Si aucun type n’est spécifié, le type de `element` ce type est déduit à partir de `collection`.
`collection`	Obligatoire. Fait référence à la collection sur laquelle opérer.
`clause`	facultatif. Une ou plusieurs clauses de requête, telles qu’une `Where` clause, pour affiner le résultat de la requête pour appliquer la clause d’agrégation ou les clauses à.
`expressionList`	Obligatoire. Une ou plusieurs expressions délimité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 relative aux fonctions d’agrégation plus loin dans cette rubrique.

Remarques

La Aggregate clause 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 retournent une valeur unique. Vous pouvez accéder à la valeur calculée à l’aide d’un membre du type de résultat de la requête. Les fonctions d’agrégation standard que vous pouvez utiliser sont les Allfonctions , , Any, MinLongCountMaxAverageCount, et Sum les fonctions. Ces fonctions sont familières aux développeurs qui connaissent les agrégats dans SQL. Elles sont décrites 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 sous la forme d’un 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 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 Aggregate clause peut commencer une requête, ou elle peut être incluse en tant que clause supplémentaire dans une requête. Si la Aggregate clause 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 Into clause. Si plusieurs fonctions d’agrégation sont spécifiées dans la Into clause, la requête retourne un seul type avec une propriété distincte pour référencer le résultat de chaque fonction d’agrégation dans la Into clause. Si la Aggregate clause est incluse en tant que clause supplémentaire dans une requête, le type retourné 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 Into clause.

Fonctions d’agrégation

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

Tous

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

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

Quelconque

Retourne true si un élément de la collection satisfait à une condition spécifiée ; sinon, retourne 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#)

Group

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

LongCount

Compte le nombre d’éléments dans la collection. Vous pouvez fournir une expression facultative Boolean pour compter uniquement le nombre d’éléments de la collection qui répondent à une condition. Retourne le résultat sous la forme d’un Long. Pour obtenir un exemple, consultez 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 Aggregate clause 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 User-Defined

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 IEnumerable<T> type. 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 tant qu’entrée, une collection de type IEnumerable(Of Double). Si la Median fonction d’agrégation est appelée pour un champ de requête de type Double, cette méthode est appelée. La deuxième surcharge de la Median méthode peut être passée n’importe quel type générique. La surcharge générique de la Median méthode prend un deuxième paramètre qui fait référence à l’expression Func(Of T, Double) lambda pour projeter une valeur pour un type (à partir d’une collection) comme valeur correspondante de type Double. Il délègue ensuite le calcul de la valeur médiane à l’autre surcharge de la Median méthode. 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 Median fonction d’agrégation sur une collection de type Integeret une collection de type Double. La requête qui appelle la Median fonction d’agrégation sur la collection de types Double appelle la surcharge de la Median méthode qui accepte, comme entrée, une collection de type Double. La requête qui appelle la Median fonction d’agrégation sur la collection de types Integer appelle la surcharge générique de la Median méthode.

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