Enumerable.Sum Método

Definição

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

Sobrecargas

Sum(IEnumerable<Decimal>)

Calcula a soma de uma sequência de valores Decimal.

Sum(IEnumerable<Double>)

Calcula a soma de uma sequência de valores Double.

Sum(IEnumerable<Int32>)

Calcula a soma de uma sequência de valores Int32.

Sum(IEnumerable<Int64>)

Calcula a soma de uma sequência de valores Int64.

Sum(IEnumerable<Nullable<Decimal>>)

Computa a soma de uma sequência de valores Decimal que permitem valores nulos.

Sum(IEnumerable<Nullable<Double>>)

Computa a soma de uma sequência de valores Double que permitem valores nulos.

Sum(IEnumerable<Nullable<Int32>>)

Computa a soma de uma sequência de valores Int32 que permitem valores nulos.

Sum(IEnumerable<Nullable<Int64>>)

Computa a soma de uma sequência de valores Int64 que permitem valores nulos.

Sum(IEnumerable<Nullable<Single>>)

Computa a soma de uma sequência de valores Single que permitem valores nulos.

Sum(IEnumerable<Single>)

Calcula a soma de uma sequência de valores Single.

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

Calcula a soma da sequência de valores Single obtidos pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de 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 pela invocação de uma função de transformação em cada elemento da sequência de entrada.

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 Decimal para cálculo da soma.

Retornos

Decimal

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Decimal.MaxValue.

Comentários

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 Double para cálculo da soma.

Retornos

Double

A soma dos valores na sequência.

Exceções

source é null.

Comentários

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 Int32 para cálculo da soma.

Retornos

Int32

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Int32.MaxValue.

Comentários

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 Int64 para cálculo da soma.

Retornos

Int64

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Int64.MaxValue.

Comentários

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

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

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Decimal>>)

Computa a soma de uma sequência de valores Decimal que permitem valores nulos.

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 Decimal que permitem valores nulos para cálculo da soma.

Retornos

Nullable<Decimal>

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Decimal.MaxValue.

Comentários

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

O resultado não inclui valores que são null.

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

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Double>>)

Computa a soma de uma sequência de valores Double que permitem valores nulos.

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 Double que permitem valores nulos para cálculo da soma.

Retornos

Nullable<Double>

A soma dos valores na sequência.

Exceções

source é null.

Comentários

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

O resultado não inclui valores que são null.

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

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Int32>>)

Computa a soma de uma sequência de valores Int32 que permitem valores nulos.

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 Int32 que permitem valores nulos para cálculo da soma.

Retornos

Nullable<Int32>

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Int32.MaxValue.

Comentários

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

O resultado não inclui valores que são null.

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

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Int64>>)

Computa a soma de uma sequência de valores Int64 que permitem valores nulos.

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 Int64 que permitem valores nulos para cálculo da soma.

Retornos

Nullable<Int64>

A soma dos valores na sequência.

Exceções

source é null.

A soma é maior que Int64.MaxValue.

Comentários

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

O resultado não inclui valores que são null.

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

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Single>>)

Computa a soma de uma sequência de valores Single que permitem valores nulos.

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 Single que permitem valores nulos para cálculo da soma.

Retornos

Nullable<Single>

A soma dos valores na sequência.

Exceções

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

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

O resultado não inclui valores que são null.

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 Single para cálculo da soma.

Retornos

Single

A soma dos valores na sequência.

Exceções

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 retorna zero se source não contiver elementos.

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

O resultado não inclui valores que são null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selectorque projeta os membros em source 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 Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

O resultado não inclui valores que são null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selectorque projeta os membros em source 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 Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

O resultado não inclui valores que são null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selectorque projeta os membros em source 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 Aggregate Into Sum() cláusula 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 pela invocação de 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 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

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

O resultado não inclui valores que são null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selectorque projeta os membros em source 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 Aggregate Into Sum() cláusula 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 pela invocação de 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 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

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.

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 retorna zero se source não contiver elementos.

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

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

Em Visual Basic sintaxe de expressão de consulta, uma Aggregate Into Sum() cláusula 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 pela invocação de 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 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

source ou selector é null.

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é diferente da sobrecarga específica descrita neste artigo. Para estender o exemplo para a sobrecarga descrita neste artigo, 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 retorna zero se source não contiver elementos.

O resultado não inclui valores que são null.

Você pode aplicar esse método a uma sequência de valores arbitrários se fornecer uma função, selectorque projeta os membros em source 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 Aggregate Into Sum() cláusula se traduz em uma invocação de Sum.

Confira também

Aplica-se a