Enumerable.Sum Metodo

Definizione

Spazio dei nomi:
System.Linq
Assembly:
System.Core.dll, System.Linq.dll
Assembly:
System.Core.dll
Assembly:
System.Linq.dll
Assembly:
netstandard.dll

Calcola la somma di una sequenza di valori numerici.

Overload

Nome Descrizione
Sum(IEnumerable<Nullable<Int32>>)

Calcola la somma di una sequenza di valori nullable Int32.
Sum(IEnumerable<Nullable<Single>>)

Calcola la somma di una sequenza di valori nullable Single.
Sum(IEnumerable<Single>)

Calcola la somma di una sequenza di valori Single.
Sum(IEnumerable<Nullable<Int64>>)

Calcola la somma di una sequenza di valori nullable Int64.
Sum(IEnumerable<Nullable<Double>>)

Calcola la somma di una sequenza di valori nullable Double.
Sum(IEnumerable<Double>)

Calcola la somma di una sequenza di valori Double.
Sum(IEnumerable<Int64>)

Calcola la somma di una sequenza di valori Int64.
Sum(IEnumerable<Int32>)

Calcola la somma di una sequenza di valori Int32.
Sum(IEnumerable<Decimal>)

Calcola la somma di una sequenza di valori Decimal.
Sum(IEnumerable<Nullable<Decimal>>)

Calcola la somma di una sequenza di valori nullable Decimal.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcola la somma della sequenza di Single valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcola la somma della sequenza di valori nullable Single ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcola la somma della sequenza di valori nullable Int64 ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcola la somma della sequenza di valori nullable Int32 ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcola la somma della sequenza di valori nullable Double ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcola la somma della sequenza di valori nullable Decimal ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcola la somma della sequenza di Int64 valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcola la somma della sequenza di Int32 valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcola la somma della sequenza di Double valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcola la somma della sequenza di Decimal valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

Sum(IEnumerable<Nullable<Int32>>)

Calcola la somma di una sequenza di valori nullable Int32.

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<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)

Parametri

source
IEnumerable<Nullable<Int32>>

Sequenza di valori nullable Int32 di cui calcolare la somma.

Valori restituiti

Nullable<Int32>

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Int32.MaxValue.

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Nullable<Single>>)

Calcola la somma di una sequenza di valori nullable Single.

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<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)

Parametri

source
IEnumerable<Nullable<Single>>

Sequenza di valori nullable Single di cui calcolare la somma.

Valori restituiti

Nullable<Single>

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum(IEnumerable<Nullable<Single>>) per sommare i valori di una sequenza.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Single>)

Calcola la somma di una sequenza di valori Single.

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

Parametri

source
IEnumerable<Single>

Sequenza di Single valori di cui calcolare la somma.

Valori restituiti

Single

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum(IEnumerable<Single>) per sommare i valori di una sequenza.

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

Commenti

Questo metodo restituisce zero se source non contiene elementi.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Nullable<Int64>>)

Calcola la somma di una sequenza di valori nullable Int64.

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<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)

Parametri

source
IEnumerable<Nullable<Int64>>

Sequenza di valori nullable Int64 di cui calcolare la somma.

Valori restituiti

Nullable<Int64>

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Int64.MaxValue.

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Nullable<Double>>)

Calcola la somma di una sequenza di valori nullable Double.

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<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)

Parametri

source
IEnumerable<Nullable<Double>>

Sequenza di valori nullable Double di cui calcolare la somma.

Valori restituiti

Nullable<Double>

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Double.MaxValue.

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Double>)

Calcola la somma di una sequenza di valori Double.

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

Parametri

source
IEnumerable<Double>

Sequenza di Double valori di cui calcolare la somma.

Valori restituiti

Double

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Double.MaxValue.

Commenti

Questo metodo restituisce zero se source non contiene elementi.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Int64>)

Calcola la somma di una sequenza di valori Int64.

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

Parametri

source
IEnumerable<Int64>

Sequenza di Int64 valori di cui calcolare la somma.

Valori restituiti

Int64

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Int64.MaxValue.

Commenti

Questo metodo restituisce zero se source non contiene elementi.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Int32>)

Calcola la somma di una sequenza di valori Int32.

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

Parametri

source
IEnumerable<Int32>

Sequenza di Int32 valori di cui calcolare la somma.

Valori restituiti

Int32

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Int32.MaxValue.

Commenti

Questo metodo restituisce zero se source non contiene elementi.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Decimal>)

Calcola la somma di una sequenza di valori Decimal.

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

Parametri

source
IEnumerable<Decimal>

Sequenza di Decimal valori di cui calcolare la somma.

Valori restituiti

Decimal

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Decimal.MaxValue.

Commenti

Il Sum(IEnumerable<Decimal>) metodo restituisce zero se source non contiene elementi.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

Sum(IEnumerable<Nullable<Decimal>>)

Calcola la somma di una sequenza di valori nullable Decimal.

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<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)

Parametri

source
IEnumerable<Nullable<Decimal>>

Sequenza di valori nullable Decimal di cui calcolare la somma.

Valori restituiti

Nullable<Decimal>

Somma dei valori nella sequenza.

Eccezioni

ArgumentNullException

source è null.

OverflowException

La somma è maggiore di Decimal.MaxValue.

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di Single valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Single>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Single

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Il Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) metodo restituisce zero se source non contiene elementi.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione , selector, che proietta i membri di source in un tipo numerico, in particolare Single.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di valori nullable Single ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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,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)

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Nullable<Single>>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Nullable<Single>

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione, selector, che proietta i membri di source in un tipo numerico, in particolare Nullable<Single> in C# o Nullable(Of Single) in Visual Basic.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di valori nullable Int64 ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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,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)

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Nullable<Int64>>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Nullable<Int64>

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Int64.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si fornisce una funzione, selector, che proietta i membri di source in un tipo numerico, in particolare Nullable<Int64> in C# o Nullable(Of Int64) in Visual Basic

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di valori nullable Int32 ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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,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)

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Nullable<Int32>>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Nullable<Int32>

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Int32.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione, selector, che proietta i membri di source in un tipo numerico, in particolare Nullable<Int32> in C# o Nullable(Of Int32) in Visual Basic.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di valori nullable Double ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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,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)

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Nullable<Double>>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Nullable<Double>

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Double.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione, selector, che proietta i membri di source in un tipo numerico, in particolare Nullable<Double> in C# o Nullable(Of Double) in Visual Basic.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di valori nullable Decimal ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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,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)

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Nullable<Decimal>>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Nullable<Decimal>

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Decimal.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Gli elementi in source che sono null esclusi dal calcolo della somma. Questo metodo restituisce zero se source non contiene elementi o tutti gli elementi sono null.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione, selector, che proietta i membri di source in un tipo numerico, in particolare Nullable<Decimal> in C# o Nullable(Of Decimal) in Visual Basic.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di Int64 valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Int64>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Int64

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Int64.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Questo metodo restituisce zero se source non contiene elementi.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione , selector, che proietta i membri di source in un tipo numerico, in particolare Int64.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di Int32 valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Int32>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Int32

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Int32.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Questo metodo restituisce zero se source non contiene elementi.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione , selector, che proietta i membri di source in un tipo numerico, in particolare Int32.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di Double valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Double>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Double

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Double.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

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

Commenti

Questo metodo restituisce zero se source non contiene elementi.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione , selector, che proietta i membri di source in un tipo numerico, in particolare Double.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a

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

Calcola la somma della sequenza di Decimal valori ottenuti richiamando una funzione di trasformazione in ogni elemento della sequenza di input.

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

Parametri di tipo

TSource

Tipo degli elementi di source.

Parametri

source
IEnumerable<TSource>

Sequenza di valori utilizzati per calcolare una somma.

selector
Func<TSource,Decimal>

Funzione di trasformazione da applicare a ogni elemento.

Valori restituiti

Decimal

Somma dei valori proiettati.

Eccezioni

ArgumentNullException

source o selector è null.

OverflowException

La somma è maggiore di Decimal.MaxValue.

Esempio

Nell'esempio di codice seguente viene illustrato come usare Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) per sommare i valori proiettati di una sequenza.

Annotazioni

Questo esempio di codice usa un overload del metodo diverso dall'overload specifico descritto in questo articolo. Per estendere l'esempio all'overload descritto in questo articolo, modificare il corpo della selector funzione.

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

Commenti

Questo metodo restituisce zero se source non contiene elementi.

È possibile applicare questo metodo a una sequenza di valori arbitrari se si specifica una funzione , selector, che proietta i membri di source in un tipo numerico, in particolare Decimal.

Nella sintassi dell'espressione di query Visual Basic una clausola Aggregate Into Sum() viene convertita in una chiamata di Sum.

Vedi anche

Si applica a