Enumerable.Sum Metoda

  • Reference

Definice

Obor názvů:
System.Linq
Sestavení:
System.Linq.dll
Sestavení:
System.Core.dll
Sestavení:
netstandard.dll

Vypočítá součet posloupnosti číselných hodnot.

Přetížení

Sum(IEnumerable<Decimal>)

Vypočítá součet posloupnosti Decimal hodnot.
Sum(IEnumerable<Double>)

Vypočítá součet posloupnosti Double hodnot.
Sum(IEnumerable<Int32>)

Vypočítá součet posloupnosti Int32 hodnot.
Sum(IEnumerable<Int64>)

Vypočítá součet posloupnosti Int64 hodnot.
Sum(IEnumerable<Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null.
Sum(IEnumerable<Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null.
Sum(IEnumerable<Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null.
Sum(IEnumerable<Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null.
Sum(IEnumerable<Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null.
Sum(IEnumerable<Single>)

Vypočítá součet posloupnosti Single hodnot.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá součet posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá součet posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá součet posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá součet posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum(IEnumerable<Decimal>)

Vypočítá součet posloupnosti Decimal hodnot.

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

Parametry

source
IEnumerable<Decimal>

Posloupnost Decimal hodnot k výpočtu součtu.

Návraty

Decimal

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Decimal.MaxValue.

Poznámky

Metoda Sum(IEnumerable<Decimal>) vrátí nulu, pokud source neobsahuje žádné prvky.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Double>)

Vypočítá součet posloupnosti Double hodnot.

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

Parametry

source
IEnumerable<Double>

Posloupnost Double hodnot k výpočtu součtu.

Návraty

Double

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Int32>)

Vypočítá součet posloupnosti Int32 hodnot.

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

Parametry

source
IEnumerable<Int32>

Posloupnost Int32 hodnot k výpočtu součtu.

Návraty

Int32

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Int32.MaxValue.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Int64>)

Vypočítá součet posloupnosti Int64 hodnot.

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

Parametry

source
IEnumerable<Int64>

Posloupnost Int64 hodnot k výpočtu součtu.

Návraty

Int64

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Int64.MaxValue.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null.

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)

Parametry

source
IEnumerable<Nullable<Decimal>>

Posloupnost hodnot s možnou Decimal hodnotou null k výpočtu součtu.

Návraty

Nullable<Decimal>

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Decimal.MaxValue.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null.

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)

Parametry

source
IEnumerable<Nullable<Double>>

Posloupnost hodnot s možnou Double hodnotou null k výpočtu součtu.

Návraty

Nullable<Double>

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null.

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)

Parametry

source
IEnumerable<Nullable<Int32>>

Posloupnost hodnot s možnou Int32 hodnotou null k výpočtu součtu.

Návraty

Nullable<Int32>

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Int32.MaxValue.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null.

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)

Parametry

source
IEnumerable<Nullable<Int64>>

Posloupnost hodnot s možnou Int64 hodnotou null k výpočtu součtu.

Návraty

Nullable<Int64>

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

OverflowException

Součet je větší než Int64.MaxValue.

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null.

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)

Parametry

source
IEnumerable<Nullable<Single>>

Posloupnost hodnot s možnou Single hodnotou null k výpočtu součtu.

Návraty

Nullable<Single>

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

Příklady

Následující příklad kódu ukazuje použití Sum(IEnumerable<Nullable<Single>>) k sečtení hodnot sekvence.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

Sum(IEnumerable<Single>)

Vypočítá součet posloupnosti Single hodnot.

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

Parametry

source
IEnumerable<Single>

Posloupnost Single hodnot k výpočtu součtu.

Návraty

Single

Součet hodnot v posloupnosti.

Výjimky

ArgumentNullException

source je null.

Příklady

Následující příklad kódu ukazuje použití Sum(IEnumerable<Single>) k sečtení hodnot sekvence.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.

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

Parametry typu

TSource

Typ prvků .source

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Single>

Transformační funkce, která se použije pro každý prvek.

Návraty

Single

Součet projektovaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

Příklady

Následující příklad kódu ukazuje, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Metoda Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) vrátí nulu, pokud source neobsahuje žádné prvky.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá zadává členy do číselného source typu, konkrétně Single.

V syntaxi Aggregate Into Sum() výrazu dotazu Visual Basic se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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)

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Nullable<Single>>

Transformační funkce, která se použije pro každý prvek.

Návraty

Nullable<Single>

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

Příklady

Následující příklad kódu ukazuje, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá prodá členy do číselného source typu, konkrétně Nullable<Single> v jazyce C# nebo Nullable(Of Single) v Visual Basic.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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)

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Nullable<Int64>>

Transformační funkce, která se použije pro každý prvek.

Návraty

Nullable<Int64>

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Int64.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá propojuje členy do číselného source typu, konkrétně Nullable<Int64> v jazyce C# nebo Nullable(Of Int64) v Visual Basic

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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)

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Nullable<Int32>>

Transformační funkce, která se použije pro každý prvek.

Návraty

Nullable<Int32>

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Int32.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá prodá členy do číselného source typu, konkrétně Nullable<Int32> v jazyce C# nebo Nullable(Of Int32) v Visual Basic.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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)

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Nullable<Double>>

Transformační funkce, která se použije pro každý prvek.

Návraty

Nullable<Double>

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá prodá členy do číselného source typu, konkrétně Nullable<Double> v jazyce C# nebo Nullable(Of Double) v Visual Basic.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Double>

Transformační funkce, která se použije pro každý prvek.

Návraty

Double

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá projektuje členy do číselného source typu, konkrétně Double.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Int64>

Transformační funkce, která se použije pro každý prvek.

Návraty

Int64

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Int64.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá projektuje členy do číselného source typu, konkrétně Int64.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Int32>

Transformační funkce, která se použije pro každý prvek.

Návraty

Int32

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Int32.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá projektuje členy do číselného source typu, konkrétně Int32.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Decimal>

Transformační funkce, která se použije pro každý prvek.

Návraty

Decimal

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Decimal.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá projektuje členy do číselného source typu, konkrétně Decimal.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro

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

Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

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)

Parametry typu

TSource

Typ prvků source.

Parametry

source
IEnumerable<TSource>

Posloupnost hodnot, které se používají k výpočtu součtu.

selector
Func<TSource,Nullable<Decimal>>

Transformační funkce, která se použije pro každý prvek.

Návraty

Nullable<Decimal>

Součet předpokládaných hodnot.

Výjimky

ArgumentNullException

source nebo selector je null.

OverflowException

Součet je větší než Decimal.MaxValue.

Příklady

Následující příklad kódu ukazuje použití Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

Tento příklad kódu používá přetížení metody , která se liší od konkrétního přetížení, které popisuje tento článek. Chcete-li rozšířit příklad na přetížení, které popisuje tento článek, změňte tělo selector funkce.

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

Poznámky

Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky.

Výsledek nezahrnuje hodnoty, které jsou null.

Tuto metodu můžete použít na posloupnost libovolných hodnot, pokud zadáte funkci, selectorkterá prodá členy do číselného source typu, konkrétně Nullable<Decimal> v jazyce C# nebo Nullable(Of Decimal) v Visual Basic.

V Visual Basic syntaxi Aggregate Into Sum() výrazu dotazu se klauzule překládá na vyvolání výrazu Sum.

Viz také

Platí pro