Enumerable.Sum Methode

Definition

Namespace:
System.Linq
Assemblys:
System.Core.dll, System.Linq.dll
Assembly:
System.Core.dll
Assembly:
System.Linq.dll
Assembly:
netstandard.dll

Berechnet die Summe einer Sequenz numerischer Werte.

Überlädt

Name Beschreibung
Sum(IEnumerable<Nullable<Int32>>)

Berechnet die Summe einer Abfolge von Nullwerte Int32 .
Sum(IEnumerable<Nullable<Single>>)

Berechnet die Summe einer Abfolge von Nullwerte Single .
Sum(IEnumerable<Single>)

Berechnet die Summe einer Folge von Single Werten.
Sum(IEnumerable<Nullable<Int64>>)

Berechnet die Summe einer Abfolge von Nullwerte Int64 .
Sum(IEnumerable<Nullable<Double>>)

Berechnet die Summe einer Abfolge von Nullwerte Double .
Sum(IEnumerable<Double>)

Berechnet die Summe einer Folge von Double Werten.
Sum(IEnumerable<Int64>)

Berechnet die Summe einer Folge von Int64 Werten.
Sum(IEnumerable<Int32>)

Berechnet die Summe einer Folge von Int32 Werten.
Sum(IEnumerable<Decimal>)

Berechnet die Summe einer Folge von Decimal Werten.
Sum(IEnumerable<Nullable<Decimal>>)

Berechnet die Summe einer Abfolge von Nullwerte Decimal .
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Berechnet die Summe der Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Berechnet die Summe der Sequenz von nullablen Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Berechnet die Summe der Sequenz von nullablen Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Berechnet die Summe der Sequenz von nullablen Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Berechnet die Summe der Sequenz von nullablen Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Berechnet die Summe der Sequenz von nullablen Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Berechnet die Summe der Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Berechnet die Summe der Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Berechnet die Summe der Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Berechnet die Summe der Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

Sum(IEnumerable<Nullable<Int32>>)

Berechnet die Summe einer Abfolge von Nullwerte 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)

Parameter

source
IEnumerable<Nullable<Int32>>

Eine Abfolge nullabler Int32 Werte zum Berechnen der Summe von.

Gibt zurück

Nullable<Int32>

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Int32.MaxValue.

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Nullable<Single>>)

Berechnet die Summe einer Abfolge von Nullwerte 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)

Parameter

source
IEnumerable<Nullable<Single>>

Eine Abfolge nullabler Single Werte zum Berechnen der Summe von.

Gibt zurück

Nullable<Single>

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum(IEnumerable<Nullable<Single>>) die Werte einer Sequenz addiert werden.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Single>)

Berechnet die Summe einer Folge von Single Werten.

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

Parameter

source
IEnumerable<Single>

Eine Abfolge von Single Werten zum Berechnen der Summe von.

Gibt zurück

Single

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum(IEnumerable<Single>) die Werte einer Sequenz addiert werden.

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

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Nullable<Int64>>)

Berechnet die Summe einer Abfolge von Nullwerte 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)

Parameter

source
IEnumerable<Nullable<Int64>>

Eine Abfolge nullabler Int64 Werte zum Berechnen der Summe von.

Gibt zurück

Nullable<Int64>

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Int64.MaxValue.

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Nullable<Double>>)

Berechnet die Summe einer Abfolge von Nullwerte 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)

Parameter

source
IEnumerable<Nullable<Double>>

Eine Abfolge nullabler Double Werte zum Berechnen der Summe von.

Gibt zurück

Nullable<Double>

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Double.MaxValue.

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Double>)

Berechnet die Summe einer Folge von Double Werten.

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

Parameter

source
IEnumerable<Double>

Eine Abfolge von Double Werten zum Berechnen der Summe von.

Gibt zurück

Double

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Double.MaxValue.

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Int64>)

Berechnet die Summe einer Folge von Int64 Werten.

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

Parameter

source
IEnumerable<Int64>

Eine Abfolge von Int64 Werten zum Berechnen der Summe von.

Gibt zurück

Int64

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Int64.MaxValue.

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Int32>)

Berechnet die Summe einer Folge von Int32 Werten.

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

Parameter

source
IEnumerable<Int32>

Eine Abfolge von Int32 Werten zum Berechnen der Summe von.

Gibt zurück

Int32

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Int32.MaxValue.

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Decimal>)

Berechnet die Summe einer Folge von Decimal Werten.

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

Parameter

source
IEnumerable<Decimal>

Eine Abfolge von Decimal Werten zum Berechnen der Summe von.

Gibt zurück

Decimal

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Decimal.MaxValue.

Hinweise

Die Sum(IEnumerable<Decimal>) Methode gibt null zurück, wenn source keine Elemente enthalten sind.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

Sum(IEnumerable<Nullable<Decimal>>)

Berechnet die Summe einer Abfolge von Nullwerte 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)

Parameter

source
IEnumerable<Nullable<Decimal>>

Eine Abfolge nullabler Decimal Werte zum Berechnen der Summe von.

Gibt zurück

Nullable<Decimal>

Die Summe der Werte in der Sequenz.

Ausnahmen

ArgumentNullException

source ist null.

OverflowException

Die Summe ist größer als Decimal.MaxValue.

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Single>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Single

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Die Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Methode gibt null zurück, wenn source keine Elemente enthalten sind.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion bereitstellen, selectordie die Member eines source numerischen Typs projiziert, insbesondere Single.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von nullablen Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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)

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Nullable<Single>>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Nullable<Single>

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion selector bereitstellen, die die Elemente von source in einen numerischen Typ projiziert, insbesondere Nullable<Single> in C# oder Nullable(Of Single) in Visual Basic.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von nullablen Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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)

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Nullable<Int64>>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Nullable<Int64>

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Int64.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion selector bereitstellen, die die Elemente von source in einen numerischen Typ projiziert, insbesondere Nullable<Int64> in C# oder Nullable(Of Int64) in Visual Basic

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von nullablen Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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)

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Nullable<Int32>>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Nullable<Int32>

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Int32.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion selector bereitstellen, die die Elemente von source in einen numerischen Typ projiziert, insbesondere Nullable<Int32> in C# oder Nullable(Of Int32) in Visual Basic.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von nullablen Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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)

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Nullable<Double>>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Nullable<Double>

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Double.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion selector bereitstellen, die die Elemente von source in einen numerischen Typ projiziert, insbesondere Nullable<Double> in C# oder Nullable(Of Double) in Visual Basic.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von nullablen Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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)

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Nullable<Decimal>>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Nullable<Decimal>

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Decimal.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Elemente, die source von der Berechnung der Summe ausgeschlossen sind null . Diese Methode gibt Null zurück, wenn source keine Elemente oder alle Elemente enthalten sind null.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion selector bereitstellen, die die Elemente von source in einen numerischen Typ projiziert, insbesondere Nullable<Decimal> in C# oder Nullable(Of Decimal) in Visual Basic.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Int64>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Int64

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Int64.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion bereitstellen, selectordie die Member eines source numerischen Typs projiziert, insbesondere Int64.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Int32>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Int32

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Int32.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion bereitstellen, selectordie die Member eines source numerischen Typs projiziert, insbesondere Int32.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Double>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Double

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Double.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

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

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion bereitstellen, selectordie die Member eines source numerischen Typs projiziert, insbesondere Double.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für:

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

Berechnet die Summe der Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.

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

Typparameter

TSource

Der Typ der Elemente von source.

Parameter

source
IEnumerable<TSource>

Eine Abfolge von Werten, die zum Berechnen einer Summe verwendet werden.

selector
Func<TSource,Decimal>

Eine Transformationsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

Decimal

Die Summe der projizierten Werte.

Ausnahmen

ArgumentNullException

source oder selector ist null.

OverflowException

Die Summe ist größer als Decimal.MaxValue.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) die projizierten Werte einer Sequenz addiert werden.

Note

In diesem Codebeispiel wird eine Überladung der Methode verwendet, die sich von der spezifischen Überladung unterscheidet, die in diesem Artikel beschrieben wird. Wenn Sie das Beispiel auf die in diesem Artikel beschriebene Überladung erweitern möchten, ändern Sie den Textkörper der selector Funktion.

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

Hinweise

Diese Methode gibt Null zurück, wenn source keine Elemente enthalten sind.

Sie können diese Methode auf eine Abfolge beliebiger Werte anwenden, wenn Sie eine Funktion bereitstellen, selectordie die Member eines source numerischen Typs projiziert, insbesondere Decimal.

In Visual Basic Abfrageausdruckssyntax übersetzt eine Aggregate Into Sum()-Klausel in einen Aufruf von Sum.

Weitere Informationen

Gilt für: