Enumerable.Sum Méthode

Définition

Calcule la somme d'une séquence de valeurs numériques.Computes the sum of a sequence of numeric values.

Surcharges

Sum(IEnumerable<Nullable<Int32>>)

Calcule la somme d'une séquence de valeurs Int32 nullables.Computes the sum of a sequence of nullable Int32 values.

Sum(IEnumerable<Nullable<Single>>)

Calcule la somme d'une séquence de valeurs Single nullables.Computes the sum of a sequence of nullable Single values.

Sum(IEnumerable<Nullable<Int64>>)

Calcule la somme d'une séquence de valeurs Int64 nullables.Computes the sum of a sequence of nullable Int64 values.

Sum(IEnumerable<Single>)

Calcule la somme d'une séquence de valeurs Single.Computes the sum of a sequence of Single values.

Sum(IEnumerable<Nullable<Double>>)

Calcule la somme d'une séquence de valeurs Double nullables.Computes the sum of a sequence of nullable Double values.

Sum(IEnumerable<Int32>)

Calcule la somme d'une séquence de valeurs Int32.Computes the sum of a sequence of Int32 values.

Sum(IEnumerable<Int64>)

Calcule la somme d'une séquence de valeurs Int64.Computes the sum of a sequence of Int64 values.

Sum(IEnumerable<Double>)

Calcule la somme d'une séquence de valeurs Double.Computes the sum of a sequence of Double values.

Sum(IEnumerable<Decimal>)

Calcule la somme d'une séquence de valeurs Decimal.Computes the sum of a sequence of Decimal values.

Sum(IEnumerable<Nullable<Decimal>>)

Calcule la somme d'une séquence de valeurs Decimal nullables.Computes the sum of a sequence of nullable Decimal values.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcule la somme d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcule la somme d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcule la somme d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcule la somme d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcule la somme d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcule la somme d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcule la somme d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcule la somme d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcule la somme d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcule la somme d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum(IEnumerable<Nullable<Int32>>)

Calcule la somme d'une séquence de valeurs Int32 nullables.Computes the sum of a sequence of nullable Int32 values.

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<int> Sum(System::Collections::Generic::IEnumerable<Nullable<int>> ^ source);
public static int? Sum (this System.Collections.Generic.IEnumerable<Nullable<int>> source);
static member Sum : seq<Nullable<int>> -> Nullable<int>
<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Integer))) As Nullable(Of Integer)

Paramètres

source
IEnumerable<Nullable<Int32>>

Séquence de valeurs Int32 nullables dont la somme doit être calculée.A sequence of nullable Int32 values to calculate the sum of.

Retours

Nullable<Int32>

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Nullable<Single>>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Nullable<Single>>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
 This code produces the following output:

 Total points earned: 311.39
*/
' Create an array of Nullable Single values.
Dim points() As Nullable(Of Single) =
{Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

' Get the sum of values in the list.
Dim sum As Nullable(Of Single) = points.Sum()

' Display the output.
Console.WriteLine($"Total points earned: {sum}")

' This code produces the following output:
'
' Total points earned: 311.39

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Nullable<Single>>)

Calcule la somme d'une séquence de valeurs Single nullables.Computes the sum of a sequence of nullable Single values.

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<float> Sum(System::Collections::Generic::IEnumerable<Nullable<float>> ^ source);
public static float? Sum (this System.Collections.Generic.IEnumerable<Nullable<float>> source);
static member Sum : seq<Nullable<single>> -> Nullable<single>
<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Single))) As Nullable(Of Single)

Paramètres

source
IEnumerable<Nullable<Single>>

Séquence de valeurs Single nullables dont la somme doit être calculée.A sequence of nullable Single values to calculate the sum of.

Retours

Nullable<Single>

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Nullable<Single>>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Nullable<Single>>) to sum the values of a sequence.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
 This code produces the following output:

 Total points earned: 311.39
*/
' Create an array of Nullable Single values.
Dim points() As Nullable(Of Single) =
{Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

' Get the sum of values in the list.
Dim sum As Nullable(Of Single) = points.Sum()

' Display the output.
Console.WriteLine($"Total points earned: {sum}")

' This code produces the following output:
'
' Total points earned: 311.39

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Nullable<Int64>>)

Calcule la somme d'une séquence de valeurs Int64 nullables.Computes the sum of a sequence of nullable Int64 values.

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<long> Sum(System::Collections::Generic::IEnumerable<Nullable<long>> ^ source);
public static long? Sum (this System.Collections.Generic.IEnumerable<Nullable<long>> source);
static member Sum : seq<Nullable<int64>> -> Nullable<int64>
<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Long))) As Nullable(Of Long)

Paramètres

source
IEnumerable<Nullable<Int64>>

Séquence de valeurs Int64 nullables dont la somme doit être calculée.A sequence of nullable Int64 values to calculate the sum of.

Retours

Nullable<Int64>

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Nullable<Single>>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Nullable<Single>>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
 This code produces the following output:

 Total points earned: 311.39
*/
' Create an array of Nullable Single values.
Dim points() As Nullable(Of Single) =
{Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

' Get the sum of values in the list.
Dim sum As Nullable(Of Single) = points.Sum()

' Display the output.
Console.WriteLine($"Total points earned: {sum}")

' This code produces the following output:
'
' Total points earned: 311.39

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Single>)

Calcule la somme d'une séquence de valeurs Single.Computes the sum of a sequence of Single values.

public:
[System::Runtime::CompilerServices::Extension]
 static float Sum(System::Collections::Generic::IEnumerable<float> ^ source);
public static float Sum (this System.Collections.Generic.IEnumerable<float> source);
static member Sum : seq<single> -> single
<Extension()>
Public Function Sum (source As IEnumerable(Of Single)) As Single

Paramètres

source
IEnumerable<Single>

Séquence de valeurs Single dont la somme doit être calculée.A sequence of Single values to calculate the sum of.

Retours

Single

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Single>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Single>) to sum the values of a sequence.

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/
' Create a list of Single values.
Dim numbers As New List(Of Single)(New Single() _
                               {43.68F, 1.25F, 583.7F, 6.5F})

' Get the sum of values in the list.
Dim sum As Single = numbers.Sum()

' Display the output.
Console.WriteLine($"The sum of the numbers is {sum}")

' This code produces the following output:
'
' The sum of the numbers is 635.13

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Nullable<Double>>)

Calcule la somme d'une séquence de valeurs Double nullables.Computes the sum of a sequence of nullable Double values.

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<double> Sum(System::Collections::Generic::IEnumerable<Nullable<double>> ^ source);
public static double? Sum (this System.Collections.Generic.IEnumerable<Nullable<double>> source);
static member Sum : seq<Nullable<double>> -> Nullable<double>
<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Double))) As Nullable(Of Double)

Paramètres

source
IEnumerable<Nullable<Double>>

Séquence de valeurs Double nullables dont la somme doit être calculée.A sequence of nullable Double values to calculate the sum of.

Retours

Nullable<Double>

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Nullable<Single>>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Nullable<Single>>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
 This code produces the following output:

 Total points earned: 311.39
*/
' Create an array of Nullable Single values.
Dim points() As Nullable(Of Single) =
{Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

' Get the sum of values in the list.
Dim sum As Nullable(Of Single) = points.Sum()

' Display the output.
Console.WriteLine($"Total points earned: {sum}")

' This code produces the following output:
'
' Total points earned: 311.39

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Int32>)

Calcule la somme d'une séquence de valeurs Int32.Computes the sum of a sequence of Int32 values.

public:
[System::Runtime::CompilerServices::Extension]
 static int Sum(System::Collections::Generic::IEnumerable<int> ^ source);
public static int Sum (this System.Collections.Generic.IEnumerable<int> source);
static member Sum : seq<int> -> int
<Extension()>
Public Function Sum (source As IEnumerable(Of Integer)) As Integer

Paramètres

source
IEnumerable<Int32>

Séquence de valeurs Int32 dont la somme doit être calculée.A sequence of Int32 values to calculate the sum of.

Retours

Int32

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Single>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Single>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/
' Create a list of Single values.
Dim numbers As New List(Of Single)(New Single() _
                               {43.68F, 1.25F, 583.7F, 6.5F})

' Get the sum of values in the list.
Dim sum As Single = numbers.Sum()

' Display the output.
Console.WriteLine($"The sum of the numbers is {sum}")

' This code produces the following output:
'
' The sum of the numbers is 635.13

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Int64>)

Calcule la somme d'une séquence de valeurs Int64.Computes the sum of a sequence of Int64 values.

public:
[System::Runtime::CompilerServices::Extension]
 static long Sum(System::Collections::Generic::IEnumerable<long> ^ source);
public static long Sum (this System.Collections.Generic.IEnumerable<long> source);
static member Sum : seq<int64> -> int64
<Extension()>
Public Function Sum (source As IEnumerable(Of Long)) As Long

Paramètres

source
IEnumerable<Int64>

Séquence de valeurs Int64 dont la somme doit être calculée.A sequence of Int64 values to calculate the sum of.

Retours

Int64

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Single>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Single>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/
' Create a list of Single values.
Dim numbers As New List(Of Single)(New Single() _
                               {43.68F, 1.25F, 583.7F, 6.5F})

' Get the sum of values in the list.
Dim sum As Single = numbers.Sum()

' Display the output.
Console.WriteLine($"The sum of the numbers is {sum}")

' This code produces the following output:
'
' The sum of the numbers is 635.13

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Double>)

Calcule la somme d'une séquence de valeurs Double.Computes the sum of a sequence of Double values.

public:
[System::Runtime::CompilerServices::Extension]
 static double Sum(System::Collections::Generic::IEnumerable<double> ^ source);
public static double Sum (this System.Collections.Generic.IEnumerable<double> source);
static member Sum : seq<double> -> double
<Extension()>
Public Function Sum (source As IEnumerable(Of Double)) As Double

Paramètres

source
IEnumerable<Double>

Séquence de valeurs Double dont la somme doit être calculée.A sequence of Double values to calculate the sum of.

Retours

Double

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Single>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Single>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/
' Create a list of Single values.
Dim numbers As New List(Of Single)(New Single() _
                               {43.68F, 1.25F, 583.7F, 6.5F})

' Get the sum of values in the list.
Dim sum As Single = numbers.Sum()

' Display the output.
Console.WriteLine($"The sum of the numbers is {sum}")

' This code produces the following output:
'
' The sum of the numbers is 635.13

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Decimal>)

Calcule la somme d'une séquence de valeurs Decimal.Computes the sum of a sequence of Decimal values.

public:
[System::Runtime::CompilerServices::Extension]
 static System::Decimal Sum(System::Collections::Generic::IEnumerable<System::Decimal> ^ source);
public static decimal Sum (this System.Collections.Generic.IEnumerable<decimal> source);
static member Sum : seq<decimal> -> decimal
<Extension()>
Public Function Sum (source As IEnumerable(Of Decimal)) As Decimal

Paramètres

source
IEnumerable<Decimal>

Séquence de valeurs Decimal dont la somme doit être calculée.A sequence of Decimal values to calculate the sum of.

Retours

Decimal

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Single>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Single>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/
' Create a list of Single values.
Dim numbers As New List(Of Single)(New Single() _
                               {43.68F, 1.25F, 583.7F, 6.5F})

' Get the sum of values in the list.
Dim sum As Single = numbers.Sum()

' Display the output.
Console.WriteLine($"The sum of the numbers is {sum}")

' This code produces the following output:
'
' The sum of the numbers is 635.13

Remarques

La Sum(IEnumerable<Decimal>) méthode retourne zéro si source ne contient aucun élément.The Sum(IEnumerable<Decimal>) method returns zero if source contains no elements.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum(IEnumerable<Nullable<Decimal>>)

Calcule la somme d'une séquence de valeurs Decimal nullables.Computes the sum of a sequence of nullable Decimal values.

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<System::Decimal> Sum(System::Collections::Generic::IEnumerable<Nullable<System::Decimal>> ^ source);
public static decimal? Sum (this System.Collections.Generic.IEnumerable<Nullable<decimal>> source);
static member Sum : seq<Nullable<decimal>> -> Nullable<decimal>
<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Decimal))) As Nullable(Of Decimal)

Paramètres

source
IEnumerable<Nullable<Decimal>>

Séquence de valeurs Decimal nullables dont la somme doit être calculée.A sequence of nullable Decimal values to calculate the sum of.

Retours

Nullable<Decimal>

Somme des valeurs de la séquence.The sum of the values in the sequence.

Exceptions

source a la valeur null.source is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum(IEnumerable<Nullable<Single>>) pour additionner les valeurs d’une séquence.The following code example demonstrates how to use Sum(IEnumerable<Nullable<Single>>) to sum the values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour étendre l'exemple à cette rubrique, remplacez les éléments de la séquence source par des éléments du type numérique approprié.To extend the example to this topic, substitute the elements of the source sequence with elements of the appropriate numerical type.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
 This code produces the following output:

 Total points earned: 311.39
*/
' Create an array of Nullable Single values.
Dim points() As Nullable(Of Single) =
{Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

' Get the sum of values in the list.
Dim sum As Nullable(Of Single) = points.Sum()

' Display the output.
Console.WriteLine($"Total points earned: {sum}")

' This code produces the following output:
'
' Total points earned: 311.39

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le ne de résultats inclut des valeurs qui sont null .The result doesnot include values that are null.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcule la somme d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static float Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, float> ^ selector);
public static float Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,float> selector);
static member Sum : seq<'Source> * Func<'Source, single> -> single
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Single)) As Single

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Single>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Single

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

La Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) méthode retourne zéro si source ne contient aucun élément.The Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) method returns zero if source contains no elements.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Single .You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Single.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcule la somme d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<float> Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, Nullable<float>> ^ selector);
public static float? Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<float>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Nullable(Of Single))) As Nullable(Of Single)

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Nullable<Single>>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Nullable<Single>

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Nullable<Single> en C# ou Nullable(Of Single) dans Visual Basic.You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Nullable<Single> in C# or Nullable(Of Single) in Visual Basic.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcule la somme d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<long> Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, Nullable<long>> ^ selector);
public static long? Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<long>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Nullable(Of Long))) As Nullable(Of Long)

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Nullable<Int64>>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Nullable<Int64>

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Nullable<Int64> en C# ou Nullable(Of Int64) dans Visual BasicYou can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Nullable<Int64> in C# or Nullable(Of Int64) in Visual Basic

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcule la somme d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<int> Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, Nullable<int>> ^ selector);
public static int? Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<int>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Nullable(Of Integer))) As Nullable(Of Integer)

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Nullable<Int32>>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Nullable<Int32>

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Nullable<Int32> en C# ou Nullable(Of Int32) dans Visual Basic.You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Nullable<Int32> in C# or Nullable(Of Int32) in Visual Basic.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcule la somme d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<double> Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, Nullable<double>> ^ selector);
public static double? Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<double>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Nullable(Of Double))) As Nullable(Of Double)

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Nullable<Double>>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Nullable<Double>

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs null .The result does not include values that are null.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Nullable<Double> en C# ou Nullable(Of Double) dans Visual Basic.You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Nullable<Double> in C# or Nullable(Of Double) in Visual Basic.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcule la somme d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<System::Decimal> Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, Nullable<System::Decimal>> ^ selector);
public static decimal? Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<decimal>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Nullable(Of Decimal))) As Nullable(Of Decimal)

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Nullable<Decimal>>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Nullable<Decimal>

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Le résultat n’inclut pas les valeurs de null .The result does not included values that are null.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Nullable<Decimal> en C# ou Nullable(Of Decimal) dans Visual Basic.You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Nullable<Decimal> in C# or Nullable(Of Decimal) in Visual Basic.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcule la somme d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static long Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, long> ^ selector);
public static long Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,long> selector);
static member Sum : seq<'Source> * Func<'Source, int64> -> int64
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Long)) As Long

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Int64>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Int64

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Int64 .You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Int64.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcule la somme d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static int Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int> ^ selector);
public static int Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int> selector);
static member Sum : seq<'Source> * Func<'Source, int> -> int
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Integer)) As Integer

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Int32>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Int32

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Int32 .You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Int32.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcule la somme d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static double Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, double> ^ selector);
public static double Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,double> selector);
static member Sum : seq<'Source> * Func<'Source, double> -> double
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Double)) As Double

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Double>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Double

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Double .You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Double.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcule la somme d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static System::Decimal Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Decimal> ^ selector);
public static decimal Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,decimal> selector);
static member Sum : seq<'Source> * Func<'Source, decimal> -> decimal
<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Decimal)) As Decimal

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs utilisées pour calculer une somme.A sequence of values that are used to calculate a sum.

selector
Func<TSource,Decimal>

Fonction de transformation à appliquer à chaque élément.A transform function to apply to each element.

Retours

Decimal

Somme des valeurs projetées.The sum of the projected values.

Exceptions

source ou selector est null.source or selector is null.

La somme est supérieure à MaxValue.The sum is larger than MaxValue.

Exemples

L’exemple de code suivant montre comment utiliser Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) pour additionner les valeurs projetées d’une séquence.The following code example demonstrates how to use Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) to sum the projected values of a sequence.

Notes

Cet exemple de code utilise une surcharge de cette méthode surchargée qui est différente de la surcharge spécifique décrite par cette rubrique.This code example uses an overload of this overloaded method that is different from the specific overload that this topic describes. Pour adapter l'exemple à cette rubrique, modifiez le corps de la fonction selector.To extend the example to this topic, change the body of the selector function.

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/
Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Remarques

Cette méthode retourne zéro si source ne contient aucun élément.This method returns zero if source contains no elements.

Vous pouvez appliquer cette méthode à une séquence de valeurs arbitraires si vous fournissez une fonction, selector , qui projette les membres de source dans un type numérique, en particulier Decimal .You can apply this method to a sequence of arbitrary values if you provide a function, selector, that projects the members of source into a numeric type, specifically Decimal.

Dans Visual Basic syntaxe d’expression de requête, une Aggregate Into Sum() clause se traduit par un appel de Sum .In Visual Basic query expression syntax, an Aggregate Into Sum() clause translates to an invocation of Sum.

Voir aussi

S’applique à