Enumerable.Sum Metoda

Definice

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

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

Přetížení

Name Description
Sum(IEnumerable<Single>)

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

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

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

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

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

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

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

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

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

Vypočítá součet posloupnosti hodnot nullable Decimal .
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 na každém prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá součet posloupnosti hodnot nullable Single, 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 nullable Int64, 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 nullable Int32, 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 nullable Double, 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,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,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 nullable Decimal, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum(IEnumerable<Single>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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 sekvenci

Výjimky

ArgumentNullException

source je null.

Příklady

Následující příklad kódu ukazuje, jak použít 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 syntaxi výrazu dotazu Visual Basic se klauzule Aggregate Into Sum() přeloží na vyvolání Sum.

Viz také

Platí pro

Sum(IEnumerable<Nullable<Single>>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable 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)

Parametry

source
IEnumerable<Nullable<Single>>

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

Návraty

Nullable<Single>

Součet hodnot v sekvenci

Výjimky

ArgumentNullException

source je null.

Příklady

Následující příklad kódu ukazuje, jak použít 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

Viz také

Platí pro

Sum(IEnumerable<Nullable<Int32>>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable 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)

Parametry

source
IEnumerable<Nullable<Int32>>

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

Návraty

Nullable<Int32>

Součet hodnot v sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

Viz také

Platí pro

Sum(IEnumerable<Nullable<Double>>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable 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)

Parametry

source
IEnumerable<Nullable<Double>>

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

Návraty

Nullable<Double>

Součet hodnot v sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

Viz také

Platí pro

Sum(IEnumerable<Nullable<Int64>>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable 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)

Parametry

source
IEnumerable<Nullable<Int64>>

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

Návraty

Nullable<Int64>

Součet hodnot v sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

Viz také

Platí pro

Sum(IEnumerable<Int64>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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 sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

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

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

Viz také

Platí pro

Sum(IEnumerable<Int32>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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 sekvenci

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 syntaxi výrazu dotazu Visual Basic se klauzule Aggregate Into Sum() přeloží na vyvolání Sum.

Viz také

Platí pro

Sum(IEnumerable<Double>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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 sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

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

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

Viz také

Platí pro

Sum(IEnumerable<Decimal>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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 sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

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

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

Viz také

Platí pro

Sum(IEnumerable<Nullable<Decimal>>)

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable 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)

Parametry

source
IEnumerable<Nullable<Decimal>>

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

Návraty

Nullable<Decimal>

Součet hodnot v sekvenci

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti Single 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 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 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.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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 vrátí nulu Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) , pokud source neobsahuje žádné prvky.

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

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable Single, 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.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable Int64, 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ž Hodnota Int64.MaxValue.

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.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable Int32, 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, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable Double, 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.

OverflowException

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

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.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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ž Hodnota Int64.MaxValue.

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.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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á projekty členy source do číselného typu, konkrétně Int64.

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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á projekty členy source do číselného typu, konkrétně Int32.

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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.

OverflowException

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

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.

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á projekty členy source do číselného typu, konkrétně Double.

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

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, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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á projekty členy source do číselného typu, konkrétně Decimal.

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

Viz také

Platí pro

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

Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs
Zdroj:
Sum.cs

Vypočítá součet posloupnosti hodnot nullable Decimal, 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, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení projektovaných hodnot sekvence.

Note

Tento příklad kódu používá přetížení metody, která se liší od konkrétního přetížení, které tento článek popisuje. Chcete-li rozšířit příklad na přetížení, které tento článek popisuje, 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

Položky, které source jsou vyloučeny null z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo všechny prvky jsou null.

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

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

Viz také

Platí pro