Enumerable.Sum Metoda

Reference

Definice

Obor názvů:: System.Linq

Sestavení:: System.Linq.dll

Sestavení:: System.Core.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

Přetížení

Sum(IEnumerable<Single>)	Vypočítá součet posloupnosti Single hodnot.
Sum(IEnumerable<Nullable<Int32>>)	Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null.
Sum(IEnumerable<Nullable<Single>>)	Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null.
Sum(IEnumerable<Nullable<Int64>>)	Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null.
Sum(IEnumerable<Nullable<Double>>)	Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null.
Sum(IEnumerable<Int32>)	Vypočítá součet posloupnosti Int32 hodnot.
Sum(IEnumerable<Int64>)	Vypočítá součet posloupnosti Int64 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 s možnou Decimal hodnotou null.
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<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,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,Int64>)	Vypočítá součet posloupnosti Int64 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,Int32>)	Vypočítá součet posloupnosti Int32 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,Double>)	Vypočítá součet posloupnosti Double 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,Decimal>)	Vypočítá součet posloupnosti Decimal 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<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<Single>)

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 pro výpočet 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 jazyka Visual Basic se Aggregate Into Sum() klauzule překládá na vyvolání Sum.

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Nullable<Int32>>)

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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 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 v source nástroji jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Nullable<Single>>)

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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 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 v source nástroji jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Nullable<Int64>>)

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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

Poznámky

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Nullable<Double>>)

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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 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 v source nástroji jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Int32>)

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 pro výpočet 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 jazyka Visual Basic se Aggregate Into Sum() klauzule překládá na vyvolání Sum.

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Int64>)

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 pro výpočet součtu.

Návraty

Int64

Součet hodnot v pořadí.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Double>)

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 pro výpočet součtu.

Návraty

Double

Součet hodnot v pořadí.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Decimal>)

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 pro výpočet součtu.

Návraty

Decimal

Součet hodnot v pořadí.

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

Sum(IEnumerable<Nullable<Decimal>>)

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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 pro výpočet součtu.

Návraty

Nullable<Decimal>

Součet hodnot v pořadí.

Výjimky

ArgumentNullException

source je null.

OverflowException

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

Poznámky

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

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 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 elementů .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 má použít 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í 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í popsaného v tomto článku. Pokud chcete příklad rozšířit na přetížení popsané v tomto článku, 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í nula, pokud source neobsahuje žádné prvky.

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek 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 elementů .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 má použít 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, jak použít Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) k sečtení předpokládaných hodnot sekvence.

Poznámka

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, source které jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek 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 elementů .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 má použít 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í předpokládaných hodnot sekvence.

Poznámka

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, source které jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek 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 elementů .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 má použít 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í předpokládaných hodnot sekvence.

Poznámka

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, source které jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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ů objektu 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 má použít 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í předpokládaných hodnot sekvence.

Poznámka

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, source které jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

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 u každého 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ů objektu 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 u každého prvku.

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

Poznámka

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 sekvenci libovolných hodnot, pokud zadáte funkci , selectorkterá promítá členy do číselného source typu, konkrétně Int64.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

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 u každého 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ů objektu 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 u každého prvku.

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.

Poznámka

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 sekvenci libovolných hodnot, pokud zadáte funkci , selectorkterá promítá členy do číselného source typu, konkrétně Int32.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

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 u každého 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ů objektu 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 u každého prvku.

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 sekvenci libovolných hodnot, pokud zadáte funkci , selectorkterá promítá členy do číselného source typu, konkrétně Double.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

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 u každého 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ů objektu 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 u každého prvku.

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.

Poznámka

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 sekvenci libovolných hodnot, pokud zadáte funkci , selectorkterá promítá členy do číselného source typu, konkrétně Decimal.

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro

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

Zdroj:: Sum.cs

Zdroj:: Sum.cs

Zdroj:: Sum.cs

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ů objektu 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 u každého prvku.

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.

Poznámka

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 v source nástroji jsou null vyloučeny z výpočtu součtu. Tato metoda vrátí nulu, pokud source neobsahuje žádné prvky nebo jsou všechny elementy .null

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

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

Viz také

Aggregate – klauzule (Visual Basic)

Platí pro