Enumerable.Sum Método

Definição

Namespace:
System.Linq
Assemblies:
System.Core.dll, System.Linq.dll
Assembly:
System.Core.dll
Assembly:
System.Linq.dll
Assembly:
netstandard.dll

Calcula a soma de uma sequência de valores numéricos.

Sobrecargas

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

Calcula a soma de uma sequência de valores Int32 anuláveis.
Sum(IEnumerable<Nullable<Single>>)

Calcula a soma de uma sequência de valores Single anuláveis.
Sum(IEnumerable<Single>)

Calcula a soma de uma sequência de valores Single.
Sum(IEnumerable<Nullable<Int64>>)

Calcula a soma de uma sequência de valores Int64 anuláveis.
Sum(IEnumerable<Nullable<Double>>)

Calcula a soma de uma sequência de valores Double anuláveis.
Sum(IEnumerable<Double>)

Calcula a soma de uma sequência de valores Double.
Sum(IEnumerable<Int64>)

Calcula a soma de uma sequência de valores Int64.
Sum(IEnumerable<Int32>)

Calcula a soma de uma sequência de valores Int32.
Sum(IEnumerable<Decimal>)

Calcula a soma de uma sequência de valores Decimal.
Sum(IEnumerable<Nullable<Decimal>>)

Calcula a soma de uma sequência de valores Decimal anuláveis.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula a soma da sequência de valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcula a soma da sequência de valores Single anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula a soma da sequência de valores Int64 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula a soma da sequência de valores Int32 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcula a soma da sequência de valores Double anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcula a soma da sequência de valores Decimal anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcula a soma da sequência de valores Int64 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula a soma da sequência de valores Int32 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula a soma da sequência de valores Double obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula a soma da sequência de valores Decimal obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Sum(IEnumerable<Nullable<Int32>>)

Calcula a soma de uma sequência de valores Int32 anuláveis.

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)

Parâmetros

source
IEnumerable<Nullable<Int32>>

Uma sequência de valores anuláveis Int32 para calcular a soma de.

Retornos

Nullable<Int32>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int32.MaxValue.

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Single>>)

Calcula a soma de uma sequência de valores Single anuláveis.

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)

Parâmetros

source
IEnumerable<Nullable<Single>>

Uma sequência de valores anuláveis Single para calcular a soma de.

Retornos

Nullable<Single>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

Exemplos

O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Nullable<Single>>) para somar os valores de uma sequência.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Single>)

Calcula a soma de uma sequência de valores 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

Parâmetros

source
IEnumerable<Single>

Uma sequência de valores da Single qual calcular a soma.

Retornos

Single

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

Exemplos

O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma sequência.

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

Comentários

Esse método retornará zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Int64>>)

Calcula a soma de uma sequência de valores Int64 anuláveis.

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)

Parâmetros

source
IEnumerable<Nullable<Int64>>

Uma sequência de valores anuláveis Int64 para calcular a soma de.

Retornos

Nullable<Int64>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int64.MaxValue.

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Double>>)

Calcula a soma de uma sequência de valores Double anuláveis.

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)

Parâmetros

source
IEnumerable<Nullable<Double>>

Uma sequência de valores anuláveis Double para calcular a soma de.

Retornos

Nullable<Double>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Double.MaxValue.

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Double>)

Calcula a soma de uma sequência de valores 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

Parâmetros

source
IEnumerable<Double>

Uma sequência de valores da Double qual calcular a soma.

Retornos

Double

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Double.MaxValue.

Comentários

Esse método retornará zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Int64>)

Calcula a soma de uma sequência de valores 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

Parâmetros

source
IEnumerable<Int64>

Uma sequência de valores da Int64 qual calcular a soma.

Retornos

Int64

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int64.MaxValue.

Comentários

Esse método retornará zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Int32>)

Calcula a soma de uma sequência de valores 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

Parâmetros

source
IEnumerable<Int32>

Uma sequência de valores da Int32 qual calcular a soma.

Retornos

Int32

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int32.MaxValue.

Comentários

Esse método retornará zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Decimal>)

Calcula a soma de uma sequência de valores 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

Parâmetros

source
IEnumerable<Decimal>

Uma sequência de valores da Decimal qual calcular a soma.

Retornos

Decimal

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Decimal.MaxValue.

Comentários

O Sum(IEnumerable<Decimal>) método retornará zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Decimal>>)

Calcula a soma de uma sequência de valores Decimal anuláveis.

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)

Parâmetros

source
IEnumerable<Nullable<Decimal>>

Uma sequência de valores anuláveis Decimal para calcular a soma de.

Retornos

Nullable<Decimal>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior que Decimal.MaxValue.

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Single>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Single

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

O Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) método retornará zero se source não contiver elementos.

Você pode aplicar esse método a uma sequência de valores arbitrários se você fornecer uma função, selectorque projeta os membros de source um tipo numérico, especificamente Single.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Single anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Nullable<Single>>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Nullable<Single>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selector, que projeta os membros do source em um tipo numérico, especificamente Nullable<Single> em C# ou Nullable(Of Single) em Visual Basic.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Int64 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Nullable<Int64>>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Nullable<Int64>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Int64.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selector, que projeta os membros do source em um tipo numérico, especificamente Nullable<Int64> em C# ou Nullable(Of Int64) em Visual Basic

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Int32 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Nullable<Int32>>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Nullable<Int32>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Int32.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selector, que projeta os membros do source em um tipo numérico, especificamente Nullable<Int32> em C# ou Nullable(Of Int32) em Visual Basic.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Double anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Nullable<Double>>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Nullable<Double>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Double.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selector, que projeta os membros do source em um tipo numérico, especificamente Nullable<Double> em C# ou Nullable(Of Double) em Visual Basic.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Decimal anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Nullable<Decimal>>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Nullable<Decimal>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Decimal.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Itens em source que são null excluídos da computação da soma. Esse método retornará zero se source não contiver elementos ou todos os elementos forem null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selector, que projeta os membros do source em um tipo numérico, especificamente Nullable<Decimal> em C# ou Nullable(Of Decimal) em Visual Basic.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Int64 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Int64>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Int64

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Int64.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Esse método retornará zero se source não contiver elementos.

Você pode aplicar esse método a uma sequência de valores arbitrários se você fornecer uma função, selectorque projeta os membros de source um tipo numérico, especificamente Int64.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Int32 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Int32>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Int32

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Int32.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Esse método retornará zero se source não contiver elementos.

Você pode aplicar esse método a uma sequência de valores arbitrários se você fornecer uma função, selectorque projeta os membros de source um tipo numérico, especificamente Int32.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Double obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Double>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Double

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Double.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

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

Comentários

Esse método retornará zero se source não contiver elementos.

Você pode aplicar esse método a uma sequência de valores arbitrários se você fornecer uma função, selectorque projeta os membros de source um tipo numérico, especificamente Double.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a

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

Calcula a soma da sequência de valores Decimal obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Parâmetros de tipo

TSource

O tipo dos elementos de source.

Parâmetros

source
IEnumerable<TSource>

Uma sequência de valores que são usados para calcular uma soma.

selector
Func<TSource,Decimal>

Uma função de transformação a ser aplicada a cada elemento.

Retornos

Decimal

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior que Decimal.MaxValue.

Exemplos

O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) para somar os valores projetados de uma sequência.

Note

Este exemplo de código usa uma sobrecarga do método diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo para a sobrecarga que este artigo descreve, altere o corpo da selector função.

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

Comentários

Esse método retornará zero se source não contiver elementos.

Você pode aplicar esse método a uma sequência de valores arbitrários se você fornecer uma função, selectorque projeta os membros de source um tipo numérico, especificamente Decimal.

Em Visual Basic sintaxe de expressão de consulta, uma cláusula Aggregate Into Sum() se traduz em uma invocação de Sum.

Confira também

Aplica-se a