Enumerable.Sum Método

Referência

Definição

Namespace:: System.Linq

Assembly:: System.Linq.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

Sobrecargas

Sum(IEnumerable<Single>)	Calcula a soma de uma sequência de valores Single.
Sum(IEnumerable<Nullable<Int32>>)	Computa a soma de uma sequência de valores Int32 que permitem valores nulos.
Sum(IEnumerable<Nullable<Single>>)	Computa a soma de uma sequência de valores Single 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<Double>>)	Computa a soma de uma sequência de valores Double que permitem valores nulos.
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<Double>)	Calcula a soma de uma sequência de valores Double.
Sum(IEnumerable<Decimal>)	Calcula a soma de uma sequência de valores Decimal.
Sum(IEnumerable<Nullable<Decimal>>)	Computa a soma de uma sequência de valores Decimal que permitem valores nulos.
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<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,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,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,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,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<Single>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Int32>>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int32.MaxValue.

Comentários

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Single>>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Int64>>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int64.MaxValue.

Comentários

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Double>>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Double.MaxValue.

Comentários

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Int32>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int32.MaxValue.

Comentários

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

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Int64>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Int64.MaxValue.

Comentários

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

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Double>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Double.MaxValue.

Comentários

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

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Decimal>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Decimal>>)

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

ArgumentNullException

source é null.

OverflowException

A soma é maior que Decimal.MaxValue.

Comentários

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observação

Este exemplo de código usa uma sobrecarga do método que é 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 fornecer uma função, selector, que projeta os membros de source em um tipo numérico, especificamente Single.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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

Os 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 de source em um tipo numérico, especificamente Nullable<Int64> em C# ou Nullable(Of Int64) no Visual Basic

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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

Os 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.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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

Os 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 de source em um tipo numérico, especificamente Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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

Os 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 de source em um tipo numérico, especificamente Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observação

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 fornecer uma função , selector, que projeta os membros de source em um tipo numérico, especificamente Int64.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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 fornecer uma função , selector, que projeta os membros de source em um tipo numérico, especificamente Int32.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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 fornecer uma função , selector, que projeta os membros de source em um tipo numérico, especificamente Double.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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 fornecer uma função , selector, que projeta os membros de source em um tipo numérico, especificamente Decimal.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

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

Origem:: Sum.cs

Origem:: Sum.cs

Origem:: Sum.cs

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

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.

Observaçã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

Os 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 , selectorque projeta os membros de source em um tipo numérico, especificamente Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic.

Na sintaxe da expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula é convertida em uma invocação de Sum.

Confira também

Cláusula Aggregate (Visual Basic)

Aplica-se a

Compartilhar via

Enumerable.Sum Método

Definição

Sobrecargas

Sum(IEnumerable<Single>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Int32>>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Single>>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Int64>>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Double>>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Int32>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Int64>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Double>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Decimal>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Sum(IEnumerable<Nullable<Decimal>>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos