FilteredWindow<TKey,TSource> Class

Definition

Derived class from Window where additional semantics are applied when a filter is present

public sealed class FilteredWindow<TKey,TSource> : Microsoft.StreamProcessing.Window<TKey,TSource>
type FilteredWindow<'Key, 'Source> = class
    inherit Window<'Key, 'Source>
Public NotInheritable Class FilteredWindow(Of TKey, TSource)
Inherits Window(Of TKey, TSource)

Type Parameters

TKey

Grouping key type for input data

TSource

Event payload type for input data

Inheritance
FilteredWindow<TKey,TSource>

Fields

Filter

The filter associated with the given window. Defaults to null.

(Inherited from Window<TKey,TSource>)

Methods

Average(Expression<Func<TSource,BigInteger>>)

Computes a time-sensitive average aggregate over BigIntegers using "snapshot windows" (SI terminology). Note that the accumulator internally is a BigInteger datatype.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Byte>>)

Computes a time-sensitive average aggregate over bytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

Average(Expression<Func<TSource,Complex>>)

Computes a time-sensitive average aggregate over Complexs using "snapshot windows" (SI terminology). Note that the accumulator internally is a Complex datatype.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Decimal>>)

Computes a time-sensitive average aggregate over decimals using "snapshot windows" (SI terminology). Note that the accumulator internally is a decimal datatype.

Average(Expression<Func<TSource,Double>>)

Computes a time-sensitive average aggregate over doubles using "snapshot windows" (SI terminology). Note that the accumulator internally is a double datatype.

Average(Expression<Func<TSource,Int16>>)

Computes a time-sensitive average aggregate over shorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

Average(Expression<Func<TSource,Int32>>)

Computes a time-sensitive average aggregate over ints using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

Average(Expression<Func<TSource,Int64>>)

Computes a time-sensitive average aggregate over longs using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

Average(Expression<Func<TSource,Nullable<BigInteger>>>)

Computes a time-sensitive average aggregate over nullable BigIntegers using "snapshot windows" (SI terminology). Note that the accumulator internally is a BigInteger datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Byte>>>)

Computes a time-sensitive average aggregate over nullable bytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Complex>>>)

Computes a time-sensitive average aggregate over nullable Complexs using "snapshot windows" (SI terminology). Note that the accumulator internally is a Complex datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Decimal>>>)

Computes a time-sensitive average aggregate over nullable decimals using "snapshot windows" (SI terminology). Note that the accumulator internally is a decimal datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Double>>>)

Computes a time-sensitive average aggregate over nullable doubles using "snapshot windows" (SI terminology). Note that the accumulator internally is a double datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Int16>>>)

Computes a time-sensitive average aggregate over nullable shorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Int32>>>)

Computes a time-sensitive average aggregate over nullable ints using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Int64>>>)

Computes a time-sensitive average aggregate over nullable longs using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<SByte>>>)

Computes a time-sensitive average aggregate over nullable sbytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<Single>>>)

Computes a time-sensitive average aggregate over nullable floats using "snapshot windows" (SI terminology). Note that the accumulator internally is a float datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<UInt16>>>)

Computes a time-sensitive average aggregate over nullable ushorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<UInt32>>>)

Computes a time-sensitive average aggregate over nullable uints using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,Nullable<UInt64>>>)

Computes a time-sensitive average aggregate over nullable ulongs using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
Average(Expression<Func<TSource,SByte>>)

Computes a time-sensitive average aggregate over sbytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

Average(Expression<Func<TSource,Single>>)

Computes a time-sensitive average aggregate over floats using "snapshot windows" (SI terminology). Note that the accumulator internally is a float datatype.

Average(Expression<Func<TSource,UInt16>>)

Computes a time-sensitive average aggregate over ushorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

Average(Expression<Func<TSource,UInt32>>)

Computes a time-sensitive average aggregate over uints using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

Average(Expression<Func<TSource,UInt64>>)

Computes a time-sensitive average aggregate over ulongs using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

AverageSquares(Expression<Func<TSource,BigInteger>>)

Computes a time-sensitive average-squares aggregate over BigIntegers using "snapshot windows" (SI terminology). Note that the accumulator internally is a BigInteger datatype.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Byte>>)

Computes a time-sensitive average squares aggregate over bytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

AverageSquares(Expression<Func<TSource,Complex>>)

Computes a time-sensitive average-squares aggregate over Complexs using "snapshot windows" (SI terminology). Note that the accumulator internally is a Complex datatype.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Decimal>>)

Computes a time-sensitive average squares aggregate over decimals using "snapshot windows" (SI terminology). Note that the accumulator internally is a decimal datatype.

AverageSquares(Expression<Func<TSource,Double>>)

Computes a time-sensitive average squares aggregate over doubles using "snapshot windows" (SI terminology). Note that the accumulator internally is a double datatype.

AverageSquares(Expression<Func<TSource,Int16>>)

Computes a time-sensitive average squares aggregate over shorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

AverageSquares(Expression<Func<TSource,Int32>>)

Computes a time-sensitive average squares aggregate over ints using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

AverageSquares(Expression<Func<TSource,Int64>>)

Computes a time-sensitive average squares aggregate over longs using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

AverageSquares(Expression<Func<TSource,Nullable<BigInteger>>>)

Computes a time-sensitive average-squares aggregate over nullable BigIntegers using "snapshot windows" (SI terminology). Note that the accumulator internally is a BigInteger datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Byte>>>)

Computes a time-sensitive average-squares aggregate over nullable bytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Complex>>>)

Computes a time-sensitive average-squares aggregate over nullable Complexs using "snapshot windows" (SI terminology). Note that the accumulator internally is a Complex datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Decimal>>>)

Computes a time-sensitive average-squares aggregate over nullable decimals using "snapshot windows" (SI terminology). Note that the accumulator internally is a decimal datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Double>>>)

Computes a time-sensitive average-squares aggregate over nullable doubles using "snapshot windows" (SI terminology). Note that the accumulator internally is a double datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Int16>>>)

Computes a time-sensitive average-squares aggregate over nullable shorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Int32>>>)

Computes a time-sensitive average-squares aggregate over nullable ints using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Int64>>>)

Computes a time-sensitive average-squares aggregate over nullable longs using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<SByte>>>)

Computes a time-sensitive average-squares aggregate over nullable sbytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<Single>>>)

Computes a time-sensitive average-squares aggregate over nullable floats using "snapshot windows" (SI terminology). Note that the accumulator internally is a float datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<UInt16>>>)

Computes a time-sensitive average-squares aggregate over nullable ushorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<UInt32>>>)

Computes a time-sensitive average-squares aggregate over nullable uints using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,Nullable<UInt64>>>)

Computes a time-sensitive average-squares aggregate over nullable ulongs using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype and that nulls have no affect on the average.

(Inherited from Window<TKey,TSource>)
AverageSquares(Expression<Func<TSource,SByte>>)

Computes a time-sensitive average squares aggregate over sbytes using "snapshot windows" (SI terminology). Note that the accumulator internally is a long datatype.

AverageSquares(Expression<Func<TSource,Single>>)

Computes a time-sensitive average squares aggregate over floats using "snapshot windows" (SI terminology). Note that the accumulator internally is a float datatype.

AverageSquares(Expression<Func<TSource,UInt16>>)

Computes a time-sensitive average squares aggregate over ushorts using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

AverageSquares(Expression<Func<TSource,UInt32>>)

Computes a time-sensitive average squares aggregate over uints using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

AverageSquares(Expression<Func<TSource,UInt64>>)

Computes a time-sensitive average squares aggregate over ulongs using "snapshot windows" (SI terminology). Note that the accumulator internally is a ulong datatype.

Count()

Computes a time-sensitive count aggregate using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
CountNotNull<TValue>(Expression<Func<TSource,TValue>>)

Computes a time-sensitive count aggregate of the non-null values using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Max<TValue>(Expression<Func<TSource,TValue>>)

Computes a time-sensitive maximum aggregate using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Max<TValue>(Expression<Func<TSource,TValue>>, Expression<Comparison<TValue>>)

Computes a time-sensitive maximum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.

(Inherited from Window<TKey,TSource>)
Max<TValue>(Expression<Func<TSource,TValue>>, IComparerExpression<TValue>)

Computes a time-sensitive maximum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.

(Inherited from Window<TKey,TSource>)
Min<TValue>(Expression<Func<TSource,TValue>>)

Computes a time-sensitive minimum aggregate using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Min<TValue>(Expression<Func<TSource,TValue>>, Expression<Comparison<TValue>>)

Computes a time-sensitive minimum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.

(Inherited from Window<TKey,TSource>)
Min<TValue>(Expression<Func<TSource,TValue>>, IComparerExpression<TValue>)

Computes a time-sensitive minimum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.

(Inherited from Window<TKey,TSource>)
PercentileContinuous(Double, Expression<Func<TSource,Double>>)

Computes a percentile continuous aggregate.

(Inherited from Window<TKey,TSource>)
PercentileContinuous(Expression<Comparison<Double>>, Double, Expression<Func<TSource,Double>>)

Computes a percentile continuous aggregate.

(Inherited from Window<TKey,TSource>)
PercentileDiscrete(Double, Expression<Func<TSource,Double>>)

Computes a percentile discrete aggregate.

(Inherited from Window<TKey,TSource>)
PercentileDiscrete(Expression<Comparison<Double>>, Double, Expression<Func<TSource,Double>>)

Computes a percentile discrete aggregate.

(Inherited from Window<TKey,TSource>)
PopulationStandardDeviation(Expression<Func<TSource,Nullable<Double>>>)

Computes the population standard deviation of the elements in the window.

(Inherited from Window<TKey,TSource>)
PopulationStandardDeviation(Expression<Func<TSource,Nullable<Int64>>>)

Computes the population standard deviation of the elements in the window.

(Inherited from Window<TKey,TSource>)
PopulationVariance(Expression<Func<TSource,Nullable<Double>>>)

Computes the population variance of the elements in the window.

(Inherited from Window<TKey,TSource>)
PopulationVariance(Expression<Func<TSource,Nullable<Int64>>>)

Computes the population variance of the elements in the window.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,BigInteger>>)

Computes a time-sensitive product aggregate over BigIntegers using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Byte>>)

Computes a time-sensitive product aggregate over bytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Complex>>)

Computes a time-sensitive product aggregate over Complexs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Decimal>>)

Computes a time-sensitive product aggregate over decimals using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Double>>)

Computes a time-sensitive product aggregate over doubles using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Int16>>)

Computes a time-sensitive product aggregate over shorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Int32>>)

Computes a time-sensitive product aggregate over ints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Int64>>)

Computes a time-sensitive product aggregate over longs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<BigInteger>>>)

Computes a time-sensitive sum aggregate over nullable BigIntegers using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Byte>>>)

Computes a time-sensitive sum aggregate over nullable bytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Complex>>>)

Computes a time-sensitive sum aggregate over nullable Complexs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Decimal>>>)

Computes a time-sensitive sum aggregate over nullable decimals using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Double>>>)

Computes a time-sensitive sum aggregate over nullable doubles using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Int16>>>)

Computes a time-sensitive sum aggregate over nullable shorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Int32>>>)

Computes a time-sensitive sum aggregate over nullable ints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Int64>>>)

Computes a time-sensitive sum aggregate over nullable longs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<SByte>>>)

Computes a time-sensitive sum aggregate over nullable sbytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<Single>>>)

Computes a time-sensitive sum aggregate over nullable floats using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<UInt16>>>)

Computes a time-sensitive sum aggregate over nullable ushorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<UInt32>>>)

Computes a time-sensitive sum aggregate over nullable uints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Nullable<UInt64>>>)

Computes a time-sensitive sum aggregate over nullable ulongs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,SByte>>)

Computes a time-sensitive product aggregate over sbytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,Single>>)

Computes a time-sensitive product aggregate over floats using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,UInt16>>)

Computes a time-sensitive product aggregate over ushorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,UInt32>>)

Computes a time-sensitive product aggregate over uints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Product(Expression<Func<TSource,UInt64>>)

Computes a time-sensitive product aggregate over ulongs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SingleOrDefault()

Computes a time-sensitive single-or-default aggregate using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
StandardDeviation(Expression<Func<TSource,Nullable<Double>>>)

Computes the sample standard deviation of the elements in the window.

(Inherited from Window<TKey,TSource>)
StandardDeviation(Expression<Func<TSource,Nullable<Int64>>>)

Computes the sample standard deviation of the elements in the window.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,BigInteger>>)

Computes a time-sensitive sum aggregate over BigIntegers using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Byte>>)

Computes a time-sensitive sum aggregate over bytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Complex>>)

Computes a time-sensitive sum aggregate over Complexs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Decimal>>)

Computes a time-sensitive sum aggregate over decimals using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Double>>)

Computes a time-sensitive sum aggregate over doubles using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Int16>>)

Computes a time-sensitive sum aggregate over shorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Int32>>)

Computes a time-sensitive sum aggregate over ints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Int64>>)

Computes a time-sensitive sum aggregate over longs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<BigInteger>>>)

Computes a time-sensitive sum aggregate over nullable BigIntegers using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Byte>>>)

Computes a time-sensitive sum aggregate over nullable bytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Complex>>>)

Computes a time-sensitive sum aggregate over nullable Complexs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Decimal>>>)

Computes a time-sensitive sum aggregate over nullable decimals using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Double>>>)

Computes a time-sensitive sum aggregate over nullable doubles using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Int16>>>)

Computes a time-sensitive sum aggregate over nullable shorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Int32>>>)

Computes a time-sensitive sum aggregate over nullable ints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Int64>>>)

Computes a time-sensitive sum aggregate over nullable longs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<SByte>>>)

Computes a time-sensitive sum aggregate over nullable sbytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<Single>>>)

Computes a time-sensitive sum aggregate over nullable floats using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<UInt16>>>)

Computes a time-sensitive sum aggregate over nullable ushorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<UInt32>>>)

Computes a time-sensitive sum aggregate over nullable uints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Nullable<UInt64>>>)

Computes a time-sensitive sum aggregate over nullable ulongs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,SByte>>)

Computes a time-sensitive sum aggregate over sbytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,Single>>)

Computes a time-sensitive sum aggregate over floats using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,UInt16>>)

Computes a time-sensitive sum aggregate over ushorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,UInt32>>)

Computes a time-sensitive sum aggregate over uints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
Sum(Expression<Func<TSource,UInt64>>)

Computes a time-sensitive sum aggregate over ulongs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,BigInteger>>)

Computes a time-sensitive sum-squares aggregate over BigIntegers using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Byte>>)

Computes a time-sensitive sum-squares aggregate over bytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Complex>>)

Computes a time-sensitive sum-squares aggregate over Complexs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Decimal>>)

Computes a time-sensitive sum-squares aggregate over decimals using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Double>>)

Computes a time-sensitive sum-squares aggregate over doubles using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Int16>>)

Computes a time-sensitive sum-squares aggregate over shorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Int32>>)

Computes a time-sensitive sum-squares aggregate over ints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Int64>>)

Computes a time-sensitive sum-squares aggregate over longs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<BigInteger>>>)

Computes a time-sensitive sum-squares aggregate over nullable BigIntegers using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Byte>>>)

Computes a time-sensitive sum-squares aggregate over nullable bytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Complex>>>)

Computes a time-sensitive sum-squares aggregate over nullable Complexs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Decimal>>>)

Computes a time-sensitive sum-squares aggregate over nullable decimals using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Double>>>)

Computes a time-sensitive sum-squares aggregate over nullable doubles using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Int16>>>)

Computes a time-sensitive sum-squares aggregate over nullable shorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Int32>>>)

Computes a time-sensitive sum-squares aggregate over nullable ints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Int64>>>)

Computes a time-sensitive sum-squares aggregate over nullable longs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<SByte>>>)

Computes a time-sensitive sum-squares aggregate over nullable sbytes using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<Single>>>)

Computes a time-sensitive sum-squares aggregate over nullable floats using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<UInt16>>>)

Computes a time-sensitive sum-squares aggregate over nullable ushorts using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<UInt32>>>)

Computes a time-sensitive sum-squares aggregate over nullable uints using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Nullable<UInt64>>>)

Computes a time-sensitive sum-squares aggregate over nullable ulongs using "snapshot windows" (SI terminology). Note that nulls have no affect on the sum.

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,SByte>>)

Computes a time-sensitive sum-squares aggregate over sbytes using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,Single>>)

Computes a time-sensitive sum-squares aggregate over floats using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,UInt16>>)

Computes a time-sensitive sum-squares aggregate over ushorts using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,UInt32>>)

Computes a time-sensitive sum-squares aggregate over uints using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
SumSquares(Expression<Func<TSource,UInt64>>)

Computes a time-sensitive sum-squares aggregate over ulongs using "snapshot windows" (SI terminology).

(Inherited from Window<TKey,TSource>)
TopK<TOrderValue>(Expression<Func<TSource,TOrderValue>>, IComparerExpression<TOrderValue>, Int32)

Computes a time-sensitive top-k aggregate using "snapshot windows" (SI terminology) based on a key selector with the provided ordering comparer.

(Inherited from Window<TKey,TSource>)
TopK<TOrderValue>(Expression<Func<TSource,TOrderValue>>, Int32)

Computes a time-sensitive top-k aggregate using "snapshot windows" (SI terminology) based on a key selector.

(Inherited from Window<TKey,TSource>)
Variance(Expression<Func<TSource,Nullable<Double>>>)

Computes the sample variance of the elements in the window.

(Inherited from Window<TKey,TSource>)
Variance(Expression<Func<TSource,Nullable<Int64>>>)

Computes the sample variance of the elements in the window.

(Inherited from Window<TKey,TSource>)
Where(Expression<Func<TSource,Boolean>>)

Filter input rows with the specified filter.

(Inherited from Window<TKey,TSource>)

Applies to