Enumerable.Sum Método

Definição

Espaço de Nomes:: System.Linq

Assemblagens:: System.Core.dll, System.Linq.dll

Assemblagem:: System.Core.dll

Assemblagem:: System.Linq.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

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

Sobrecargas

Name	Description
Sum(IEnumerable<Nullable<Int32>>)	Calcula a soma de uma sequência de valores nulos Int32 .
Sum(IEnumerable<Nullable<Single>>)	Calcula a soma de uma sequência de valores nulos Single .
Sum(IEnumerable<Single>)	Calcula a soma de uma sequência de Single valores.
Sum(IEnumerable<Nullable<Int64>>)	Calcula a soma de uma sequência de valores nulos Int64 .
Sum(IEnumerable<Nullable<Double>>)	Calcula a soma de uma sequência de valores nulos Double .
Sum(IEnumerable<Double>)	Calcula a soma de uma sequência de Double valores.
Sum(IEnumerable<Int64>)	Calcula a soma de uma sequência de Int64 valores.
Sum(IEnumerable<Int32>)	Calcula a soma de uma sequência de Int32 valores.
Sum(IEnumerable<Decimal>)	Calcula a soma de uma sequência de Decimal valores.
Sum(IEnumerable<Nullable<Decimal>>)	Calcula a soma de uma sequência de valores nulos Decimal .
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Calcula a soma da sequência de Single valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Calcula a soma da sequência de valores nulos Single que são obtidos ao invocar 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 nulos Int64 que são obtidos ao invocar 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 nulos Int32 que são obtidos ao invocar 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 nulos Double que são obtidos ao invocar 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 nulos Decimal que são obtidos ao invocar 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 Int64 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Calcula a soma da sequência de Int32 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Calcula a soma da sequência de Double valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcula a soma da sequência de Decimal valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Sum(IEnumerable<Nullable<Int32>>)

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<int> Sum(System::Collections::Generic::IEnumerable<Nullable<int>> ^ source);

public static int? Sum(this System.Collections.Generic.IEnumerable<int?> source);

static member Sum : seq<Nullable<int>> -> Nullable<int>

<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Integer))) As Nullable(Of Integer)

Parâmetros

source: IEnumerable<Nullable<Int32>>

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

Devoluções

Nullable<Int32>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Int32.MaxValue.

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Single>>)

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<float> Sum(System::Collections::Generic::IEnumerable<Nullable<float>> ^ source);

public static float? Sum(this System.Collections.Generic.IEnumerable<float?> source);

static member Sum : seq<Nullable<single>> -> Nullable<single>

<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Single))) As Nullable(Of Single)

Parâmetros

source: IEnumerable<Nullable<Single>>

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

Devoluções

Nullable<Single>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

Exemplos

O exemplo de código seguinte 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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Single>)

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

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 Single valores para calcular a soma de.

Devoluções

Single

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

Exemplos

O exemplo de código seguinte 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

Observações

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

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Int64>>)

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<long> Sum(System::Collections::Generic::IEnumerable<Nullable<long>> ^ source);

public static long? Sum(this System.Collections.Generic.IEnumerable<long?> source);

static member Sum : seq<Nullable<int64>> -> Nullable<int64>

<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Long))) As Nullable(Of Long)

Parâmetros

source: IEnumerable<Nullable<Int64>>

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

Devoluções

Nullable<Int64>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Int64.MaxValue.

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Double>>)

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<double> Sum(System::Collections::Generic::IEnumerable<Nullable<double>> ^ source);

public static double? Sum(this System.Collections.Generic.IEnumerable<double?> source);

static member Sum : seq<Nullable<double>> -> Nullable<double>

<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Double))) As Nullable(Of Double)

Parâmetros

source: IEnumerable<Nullable<Double>>

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

Devoluções

Nullable<Double>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que o Double.MaxValue.

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Double>)

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

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 Double valores para calcular a soma de.

Devoluções

Double

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que o Double.MaxValue.

Observações

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

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Int64>)

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

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 Int64 valores para calcular a soma de.

Devoluções

Int64

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Int64.MaxValue.

Observações

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

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Int32>)

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

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 Int32 valores para calcular a soma de.

Devoluções

Int32

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Int32.MaxValue.

Observações

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

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Decimal>)

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

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 Decimal valores para calcular a soma de.

Devoluções

Decimal

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Decimal.MaxValue.

Observações

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

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Sum(IEnumerable<Nullable<Decimal>>)

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<System::Decimal> Sum(System::Collections::Generic::IEnumerable<Nullable<System::Decimal>> ^ source);

public static decimal? Sum(this System.Collections.Generic.IEnumerable<decimal?> source);

static member Sum : seq<Nullable<decimal>> -> Nullable<decimal>

<Extension()>
Public Function Sum (source As IEnumerable(Of Nullable(Of Decimal))) As Nullable(Of Decimal)

Parâmetros

source: IEnumerable<Nullable<Decimal>>

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

Devoluções

Nullable<Decimal>

A soma dos valores na sequência.

Exceções

ArgumentNullException

source é null.

OverflowException

A soma é maior do que Decimal.MaxValue.

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static float Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, float> ^ selector);

public static float Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,float> selector);

static member Sum : seq<'Source> * Func<'Source, single> -> single

<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Single)) As Single

Parâmetros de Tipo Genérico

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 para aplicar a cada elemento.

Devoluções

Single

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

Este exemplo de código utiliza uma sobrecarga do método que é diferente da sobrecarga específica que este artigo descreve. Para estender o exemplo à sobrecarga que este artigo descreve, mude 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

Observações

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

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os membros de source num tipo numérico, especificamente Single.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

Calcula a soma da sequência de valores nulos Single que são obtidos ao invocar 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 Genérico

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 para aplicar a cada elemento.

Devoluções

Nullable<Single>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os elementos de source num tipo numérico, especificamente Nullable<Single> em C# ou Nullable(Of Single) em Visual Basic.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

Calcula a soma da sequência de valores nulos Int64 que são obtidos ao invocar 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 Genérico

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 para aplicar a cada elemento.

Devoluções

Nullable<Int64>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Int64.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os elementos de source num tipo numérico, especificamente Nullable<Int64> em C# ou Nullable(Of Int64) em Visual Basic

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

Calcula a soma da sequência de valores nulos Int32 que são obtidos ao invocar 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 Genérico

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 para aplicar a cada elemento.

Devoluções

Nullable<Int32>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Int32.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os elementos de source num tipo numérico, especificamente Nullable<Int32> em C# ou Nullable(Of Int32) em Visual Basic.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

Calcula a soma da sequência de valores nulos Double que são obtidos ao invocar 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 Genérico

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 para aplicar a cada elemento.

Devoluções

Nullable<Double>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que o Double.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os elementos de source num tipo numérico, especificamente Nullable<Double> em C# ou Nullable(Of Double) em Visual Basic.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

Calcula a soma da sequência de valores nulos Decimal que são obtidos ao invocar 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 Genérico

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 para aplicar a cada elemento.

Devoluções

Nullable<Decimal>

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Decimal.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

Itens em source que são null excluídos do cálculo da soma. Este método retorna zero se não contiver elementos ou se source todos os elementos forem null.

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os elementos de source num tipo numérico, especificamente Nullable<Decimal> em C# ou Nullable(Of Decimal) em Visual Basic.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static long Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, long> ^ selector);

public static long Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,long> selector);

static member Sum : seq<'Source> * Func<'Source, int64> -> int64

<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Long)) As Long

Parâmetros de Tipo Genérico

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 para aplicar a cada elemento.

Devoluções

Int64

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Int64.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

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

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os membros de source num tipo numérico, especificamente Int64.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static int Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int> ^ selector);

public static int Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int> selector);

static member Sum : seq<'Source> * Func<'Source, int> -> int

<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Integer)) As Integer

Parâmetros de Tipo Genérico

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 para aplicar a cada elemento.

Devoluções

Int32

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Int32.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

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

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os membros de source num tipo numérico, especificamente Int32.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static double Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, double> ^ selector);

public static double Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,double> selector);

static member Sum : seq<'Source> * Func<'Source, double> -> double

<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Double)) As Double

Parâmetros de Tipo Genérico

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 para aplicar a cada elemento.

Devoluções

Double

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que o Double.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos 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

Observações

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

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os membros de source num tipo numérico, especificamente Double.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

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

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static System::Decimal Sum(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Decimal> ^ selector);

public static decimal Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,decimal> selector);

static member Sum : seq<'Source> * Func<'Source, decimal> -> decimal

<Extension()>
Public Function Sum(Of TSource) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Decimal)) As Decimal

Parâmetros de Tipo Genérico

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 para aplicar a cada elemento.

Devoluções

Decimal

A soma dos valores projetados.

Exceções

ArgumentNullException

source ou selector é null.

OverflowException

A soma é maior do que Decimal.MaxValue.

Exemplos

O exemplo de código seguinte demonstra como usar Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) a soma dos valores projetados de uma sequência.

Note

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

Observações

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

Pode aplicar este método a uma sequência de valores arbitrários se fornecer uma função, selector, que projete os membros de source num tipo numérico, especificamente Decimal.

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

Ver também

Agregada (Visual Basic)

Aplica-se a

Comentários

Esta página foi útil?