Enumerable.Sum Metod

Definition

Namnområde:: System.Linq

Sammansättningar:: System.Core.dll, System.Linq.dll

Sammansättning:: System.Core.dll

Sammansättning:: System.Linq.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Beräknar summan av en sekvens med numeriska värden.

Överlagringar

Name	Description
Sum(IEnumerable<Nullable<Int32>>)	Beräknar summan av en sekvens med null-värden Int32 .
Sum(IEnumerable<Nullable<Single>>)	Beräknar summan av en sekvens med null-värden Single .
Sum(IEnumerable<Single>)	Beräknar summan av en sekvens med Single värden.
Sum(IEnumerable<Nullable<Int64>>)	Beräknar summan av en sekvens med null-värden Int64 .
Sum(IEnumerable<Nullable<Double>>)	Beräknar summan av en sekvens med null-värden Double .
Sum(IEnumerable<Double>)	Beräknar summan av en sekvens med Double värden.
Sum(IEnumerable<Int64>)	Beräknar summan av en sekvens med Int64 värden.
Sum(IEnumerable<Int32>)	Beräknar summan av en sekvens med Int32 värden.
Sum(IEnumerable<Decimal>)	Beräknar summan av en sekvens med Decimal värden.
Sum(IEnumerable<Nullable<Decimal>>)	Beräknar summan av en sekvens med null-värden Decimal .
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Beräknar summan av sekvensen med Single värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Beräknar summan av sekvensen med null-värden Single som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Beräknar summan av sekvensen med null-värden Int64 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Beräknar summan av sekvensen med null-värden Int32 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Beräknar summan av sekvensen med null-värden Double som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Beräknar summan av sekvensen med null-värden Decimal som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Beräknar summan av sekvensen med Int64 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Beräknar summan av sekvensen med Int32 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Beräknar summan av sekvensen med Double värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Beräknar summan av sekvensen med Decimal värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

Sum(IEnumerable<Nullable<Int32>>)

Beräknar summan av en sekvens med null-värden 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)

Parametrar

source: IEnumerable<Nullable<Int32>>

En sekvens med null-värden Int32 för att beräkna summan av.

Returer

Nullable<Int32>

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Int32.MaxValue.

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Nullable<Single>>)

Beräknar summan av en sekvens med null-värden 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)

Parametrar

source: IEnumerable<Nullable<Single>>

En sekvens med null-värden Single för att beräkna summan av.

Returer

Nullable<Single>

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

Exempel

Följande kodexempel visar hur du använder Sum(IEnumerable<Nullable<Single>>) för att summera värdena för en sekvens.

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

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Single>)

Beräknar summan av en sekvens med Single värden.

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

Parametrar

source: IEnumerable<Single>

En sekvens med Single värden för att beräkna summan av.

Returer

Single

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

Exempel

Följande kodexempel visar hur du använder Sum(IEnumerable<Single>) för att summera värdena för en sekvens.

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

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Nullable<Int64>>)

Beräknar summan av en sekvens med null-värden 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)

Parametrar

source: IEnumerable<Nullable<Int64>>

En sekvens med null-värden Int64 för att beräkna summan av.

Returer

Nullable<Int64>

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Int64.MaxValue.

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Nullable<Double>>)

Beräknar summan av en sekvens med null-värden 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)

Parametrar

source: IEnumerable<Nullable<Double>>

En sekvens med null-värden Double för att beräkna summan av.

Returer

Nullable<Double>

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Double.MaxValue.

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Double>)

Beräknar summan av en sekvens med Double värden.

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

Parametrar

source: IEnumerable<Double>

En sekvens med Double värden för att beräkna summan av.

Returer

Double

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Double.MaxValue.

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Int64>)

Beräknar summan av en sekvens med Int64 värden.

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

Parametrar

source: IEnumerable<Int64>

En sekvens med Int64 värden för att beräkna summan av.

Returer

Int64

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Int64.MaxValue.

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Int32>)

Beräknar summan av en sekvens med Int32 värden.

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

Parametrar

source: IEnumerable<Int32>

En sekvens med Int32 värden för att beräkna summan av.

Returer

Int32

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Int32.MaxValue.

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Decimal>)

Beräknar summan av en sekvens med Decimal värden.

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

Parametrar

source: IEnumerable<Decimal>

En sekvens med Decimal värden för att beräkna summan av.

Returer

Decimal

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Decimal.MaxValue.

Kommentarer

Metoden Sum(IEnumerable<Decimal>) returnerar noll om source den inte innehåller några element.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Sum(IEnumerable<Nullable<Decimal>>)

Beräknar summan av en sekvens med null-värden 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)

Parametrar

source: IEnumerable<Nullable<Decimal>>

En sekvens med null-värden Decimal för att beräkna summan av.

Returer

Nullable<Decimal>

Summan av värdena i sekvensen.

Undantag

ArgumentNullException

source är null.

OverflowException

Summan är större än Decimal.MaxValue.

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med Single värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Single>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Single

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

I det här kodexemplet används en överlagring av metoden som skiljer sig från den specifika överlagring som beskrivs i den här artikeln. Om du vill utöka exemplet till den överlagring som beskrivs i den här artikeln ändrar du funktionens selector brödtext.

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

Kommentarer

Metoden Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) returnerar noll om source den inte innehåller några element.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna source i till en numerisk typ, särskilt Single.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med null-värden Single som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Nullable<Single>>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Nullable<Single>

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

Du kan använda den här metoden i en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna i source till en numerisk typ, särskilt Nullable<Single> i C# eller Nullable(Of Single) i Visual Basic.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med null-värden Int64 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Nullable<Int64>>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Nullable<Int64>

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Int64.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna i source till en numerisk typ, särskilt Nullable<Int64> i C# eller Nullable(Of Int64) i Visual Basic

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med null-värden Int32 som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Nullable<Int32>>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Nullable<Int32>

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Int32.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

Du kan använda den här metoden i en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna i source till en numerisk typ, särskilt Nullable<Int32> i C# eller Nullable(Of Int32) i Visual Basic.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med null-värden Double som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Nullable<Double>>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Nullable<Double>

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Double.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

Du kan använda den här metoden i en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna i source till en numerisk typ, särskilt Nullable<Double> i C# eller Nullable(Of Double) i Visual Basic.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med null-värden Decimal som erhålls genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Nullable<Decimal>>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Nullable<Decimal>

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Decimal.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Objekt i source som är null exkluderade från beräkningen av summan. Den här metoden returnerar noll om source inte innehåller några element eller om alla element är null.

Du kan använda den här metoden i en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna i source till en numerisk typ, särskilt Nullable<Decimal> i C# eller Nullable(Of Decimal) i Visual Basic.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med Int64 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Int64>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Int64

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Int64.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna source i till en numerisk typ, särskilt Int64.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med Int32 värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Int32>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Int32

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Int32.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna source i till en numerisk typ, särskilt Int32.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med Double värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Double>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Double

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Double.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

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

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna source i till en numerisk typ, särskilt Double.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

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

Beräknar summan av sekvensen med Decimal värden som hämtas genom att anropa en transformeringsfunktion på varje element i indatasekvensen.

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

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source: IEnumerable<TSource>

En sekvens med värden som används för att beräkna en summa.

selector: Func<TSource,Decimal>

En transformeringsfunktion som ska tillämpas på varje element.

Returer

Decimal

Summan av de beräknade värdena.

Undantag

ArgumentNullException

source eller selector är null.

OverflowException

Summan är större än Decimal.MaxValue.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) för att summera de beräknade värdena för en sekvens.

Note

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

Structure Package
    Public Company As String
    Public Weight As Double
End Structure

Sub SumEx1()
    ' Create a list of Package values.
    Dim packages As New List(Of Package)(New Package() _
     {New Package With {.Company = "Coho Vineyard", .Weight = 25.2},
      New Package With {.Company = "Lucerne Publishing", .Weight = 18.7},
      New Package With {.Company = "Wingtip Toys", .Weight = 6.0},
      New Package With {.Company = "Adventure Works", .Weight = 33.8}})

    ' Sum the values from each item's Weight property.
    Dim totalWeight As Double = packages.Sum(Function(pkg) _
                                             pkg.Weight)

    ' Display the result.
    Console.WriteLine($"The total weight of the packages is: {totalWeight}")
End Sub

' This code produces the following output:
'
' The total weight of the packages is: 83.7

Kommentarer

Den här metoden returnerar noll om source den inte innehåller några element.

Du kan använda den här metoden för en sekvens med godtyckliga värden om du anger en funktion, selector, som projicerar medlemmarna source i till en numerisk typ, särskilt Decimal.

I Visual Basic frågeuttryckssyntax översätts en Aggregate Into Sum()-sats till ett anrop av Sum.

Se även

Aggregate Clause (Visual Basic)

Gäller för

Feedback

Var den här sidan till hjälp?