Queryable.Sum Metod

Definition

Namnområde:
System.Linq
Sammansättningar:
System.Core.dll, System.Linq.Queryable.dll
Sammansättningar:
netstandard.dll, System.Linq.Queryable.dll
Sammansättning:
System.Linq.Queryable.dll
Sammansättning:
System.Core.dll
Sammansättning:
netstandard.dll

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

Överlagringar

Name Description
Sum(IQueryable<Single>)

Beräknar summan av en sekvens med Single värden.
Sum(IQueryable<Nullable<Single>>)

Beräknar summan av en sekvens med null-värden Single .
Sum(IQueryable<Nullable<Int64>>)

Beräknar summan av en sekvens med null-värden Int64 .
Sum(IQueryable<Nullable<Int32>>)

Beräknar summan av en sekvens med null-värden Int32 .
Sum(IQueryable<Nullable<Double>>)

Beräknar summan av en sekvens med null-värden Double .
Sum(IQueryable<Nullable<Decimal>>)

Beräknar summan av en sekvens med null-värden Decimal .
Sum(IQueryable<Int64>)

Beräknar summan av en sekvens med Int64 värden.
Sum(IQueryable<Int32>)

Beräknar summan av en sekvens med Int32 värden.
Sum(IQueryable<Double>)

Beräknar summan av en sekvens med Double värden.
Sum(IQueryable<Decimal>)

Beräknar summan av en sekvens med Decimal värden.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)

Beräknar summan av sekvensen med Single värden som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)

Beräknar summan av sekvensen med null-värden Single som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)

Beräknar summan av sekvensen med null-värden Int64 som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>)

Beräknar summan av sekvensen med null-värden Int32 som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)

Beräknar summan av sekvensen med null-värden Double som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)

Beräknar summan av sekvensen med null-värden Decimal som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)

Beräknar summan av sekvensen med Int64 värden som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>)

Beräknar summan av sekvensen med Int32 värden som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)

Beräknar summan av sekvensen med Double värden som erhålls genom att anropa en projektionsfunktion på varje element i indatasekvensen.
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)

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

Sum(IQueryable<Single>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static float Sum(System::Linq::IQueryable<float> ^ source);
public static float Sum(this System.Linq.IQueryable<float> source);
static member Sum : System.Linq.IQueryable<single> -> single
<Extension()>
Public Function Sum (source As IQueryable(Of Single)) As Single

Parametrar

source
IQueryable<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(IQueryable<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.AsQueryable().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.
*/

Dim numbers As New List(Of Single)(New Single() {43.68F, 1.25F, 583.7F, 6.5F})

Dim sum As Single = numbers.AsQueryable().Sum()

MsgBox("The sum of the numbers is " & sum)

' This code produces the following output:

' The sum of the numbers is 635.13.

Kommentarer

Metoden Sum(IQueryable<Single>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Single>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Single>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Nullable<Single>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<float> Sum(System::Linq::IQueryable<Nullable<float>> ^ source);
public static float? Sum(this System.Linq.IQueryable<float?> source);
static member Sum : System.Linq.IQueryable<Nullable<single>> -> Nullable<single>
<Extension()>
Public Function Sum (source As IQueryable(Of Nullable(Of Single))) As Nullable(Of Single)

Parametrar

source
IQueryable<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(IQueryable<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.AsQueryable().Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
    This code produces the following output:

    Total points earned: 311.39
*/

Dim points As Nullable(Of Single)() = {Nothing, 0, 92.83F, Nothing, 100.0F, 37.46F, 81.1F}

Dim sum As Nullable(Of Single) = points.AsQueryable().Sum()

MsgBox("Total points earned: " & sum)

'This code produces the following output:

'Total points earned: 311.39

Kommentarer

Metoden Sum(IQueryable<Nullable<Single>>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Nullable<Single>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Nullable<Single>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Nullable<Int64>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<long> Sum(System::Linq::IQueryable<Nullable<long>> ^ source);
public static long? Sum(this System.Linq.IQueryable<long?> source);
static member Sum : System.Linq.IQueryable<Nullable<int64>> -> Nullable<int64>
<Extension()>
Public Function Sum (source As IQueryable(Of Nullable(Of Long))) As Nullable(Of Long)

Parametrar

source
IQueryable<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

Metoden Sum(IQueryable<Nullable<Int64>>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Nullable<Int64>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Nullable<Int64>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Nullable<Int32>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<int> Sum(System::Linq::IQueryable<Nullable<int>> ^ source);
public static int? Sum(this System.Linq.IQueryable<int?> source);
static member Sum : System.Linq.IQueryable<Nullable<int>> -> Nullable<int>
<Extension()>
Public Function Sum (source As IQueryable(Of Nullable(Of Integer))) As Nullable(Of Integer)

Parametrar

source
IQueryable<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

Metoden Sum(IQueryable<Nullable<Int32>>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Nullable<Int32>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Nullable<Int32>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Nullable<Double>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<double> Sum(System::Linq::IQueryable<Nullable<double>> ^ source);
public static double? Sum(this System.Linq.IQueryable<double?> source);
static member Sum : System.Linq.IQueryable<Nullable<double>> -> Nullable<double>
<Extension()>
Public Function Sum (source As IQueryable(Of Nullable(Of Double))) As Nullable(Of Double)

Parametrar

source
IQueryable<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.

Kommentarer

Metoden Sum(IQueryable<Nullable<Double>>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Nullable<Double>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Nullable<Double>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Nullable<Decimal>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static Nullable<System::Decimal> Sum(System::Linq::IQueryable<Nullable<System::Decimal>> ^ source);
public static decimal? Sum(this System.Linq.IQueryable<decimal?> source);
static member Sum : System.Linq.IQueryable<Nullable<decimal>> -> Nullable<decimal>
<Extension()>
Public Function Sum (source As IQueryable(Of Nullable(Of Decimal))) As Nullable(Of Decimal)

Parametrar

source
IQueryable<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

Metoden Sum(IQueryable<Nullable<Decimal>>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Nullable<Decimal>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Nullable<Decimal>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Int64>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static long Sum(System::Linq::IQueryable<long> ^ source);
public static long Sum(this System.Linq.IQueryable<long> source);
static member Sum : System.Linq.IQueryable<int64> -> int64
<Extension()>
Public Function Sum (source As IQueryable(Of Long)) As Long

Parametrar

source
IQueryable<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

Metoden Sum(IQueryable<Int64>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Int64>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Int64>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Int32>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static int Sum(System::Linq::IQueryable<int> ^ source);
public static int Sum(this System.Linq.IQueryable<int> source);
static member Sum : System.Linq.IQueryable<int> -> int
<Extension()>
Public Function Sum (source As IQueryable(Of Integer)) As Integer

Parametrar

source
IQueryable<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

Metoden Sum(IQueryable<Int32>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Int32>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Int32>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Double>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static double Sum(System::Linq::IQueryable<double> ^ source);
public static double Sum(this System.Linq.IQueryable<double> source);
static member Sum : System.Linq.IQueryable<double> -> double
<Extension()>
Public Function Sum (source As IQueryable(Of Double)) As Double

Parametrar

source
IQueryable<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.

Kommentarer

Metoden Sum(IQueryable<Double>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Double>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Double>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum(IQueryable<Decimal>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
[System::Runtime::CompilerServices::Extension]
 static System::Decimal Sum(System::Linq::IQueryable<System::Decimal> ^ source);
public static decimal Sum(this System.Linq.IQueryable<decimal> source);
static member Sum : System.Linq.IQueryable<decimal> -> decimal
<Extension()>
Public Function Sum (source As IQueryable(Of Decimal)) As Decimal

Parametrar

source
IQueryable<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(IQueryable<Decimal>) genererar en MethodCallExpression som representerar att anropa Sum(IQueryable<Decimal>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum(IQueryable<Decimal>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det returnerar summan av värdena i source.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static float Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, float> ^> ^ selector);
public static float Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,float>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static float Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,float>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, single>> -> single
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, single>> -> single
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Single))) As Single

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Single>>

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

Returer

Single

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<float> Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, Nullable<float>> ^> ^ selector);
public static float? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,float?>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static float? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,float?>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<single>>> -> Nullable<single>
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<single>>> -> Nullable<single>
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Nullable(Of Single)))) As Nullable(Of Single)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Nullable<Single>>>

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

Returer

Nullable<Single>

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<long> Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, Nullable<long>> ^> ^ selector);
public static long? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,long?>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static long? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,long?>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<int64>>> -> Nullable<int64>
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<int64>>> -> Nullable<int64>
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Nullable(Of Long)))) As Nullable(Of Long)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Nullable<Int64>>>

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

Returer

Nullable<Int64>

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<int> Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, Nullable<int>> ^> ^ selector);
public static int? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int?>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static int? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int?>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<int>>> -> Nullable<int>
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<int>>> -> Nullable<int>
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Nullable(Of Integer)))) As Nullable(Of Integer)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Nullable<Int32>>>

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

Returer

Nullable<Int32>

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<double> Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, Nullable<double>> ^> ^ selector);
public static double? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,double?>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static double? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,double?>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<double>>> -> Nullable<double>
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<double>>> -> Nullable<double>
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Nullable(Of Double)))) As Nullable(Of Double)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Nullable<Double>>>

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

Returer

Nullable<Double>

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static Nullable<System::Decimal> Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, Nullable<System::Decimal>> ^> ^ selector);
public static decimal? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,decimal?>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static decimal? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,decimal?>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<decimal>>> -> Nullable<decimal>
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, Nullable<decimal>>> -> Nullable<decimal>
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Nullable(Of Decimal)))) As Nullable(Of Decimal)

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Nullable<Decimal>>>

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

Returer

Nullable<Decimal>

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static long Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, long> ^> ^ selector);
public static long Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,long>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static long Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,long>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int64>> -> int64
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int64>> -> int64
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Long))) As Long

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Int64>>

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

Returer

Int64

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static int Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, int> ^> ^ selector);
public static int Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static int Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int>> -> int
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int>> -> int
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Integer))) As Integer

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Int32>>

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

Returer

Int32

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static double Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, double> ^> ^ selector);
public static double Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,double>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static double Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,double>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, double>> -> double
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, double>> -> double
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Double))) As Double

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Double>>

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

Returer

Double

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder Sum<TSource>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)

Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs
Källa:
Queryable.cs

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

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static System::Decimal Sum(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, System::Decimal> ^> ^ selector);
public static decimal Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,decimal>> selector);
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
public static decimal Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,decimal>> selector);
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, decimal>> -> decimal
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
static member Sum : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, decimal>> -> decimal
<Extension()>
Public Function Sum(Of TSource) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Decimal))) As Decimal

Typparametrar

TSource

Typen av element sourcei .

Parametrar

source
IQueryable<TSource>

En sekvens med värden av typen TSource.

selector
Expression<Func<TSource,Decimal>>

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

Returer

Decimal

Summan av de beräknade värdena.

Attribut
RequiresDynamicCodeAttribute

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>(IQueryable<TSource>, Expression<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 SumEx3()
{
    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 } };

    // Calculate the sum of all package weights.
    double totalWeight = packages.AsQueryable().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

Shared Sub SumEx3()
    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}})

    ' Calculate the sum of all package weights.
    Dim totalWeight As Double = packages.AsQueryable().Sum(Function(pkg) pkg.Weight)

    MsgBox("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 har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) genererar en MethodCallExpression som representerar att anropa Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) sig själv som en konstruerad generisk metod. Den skickar sedan till MethodCallExpression metoden för den Execute<TResult>(Expression) som representeras av IQueryProvider egenskapen för parameternProvider.source

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element i source och returnerar summan av de resulterande värdena.

Gäller för