Window<TKey,TSource> Class

Reference

Definition

Namespace:: Microsoft.StreamProcessing

Assembly:: Microsoft.StreamProcessing.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Class representing a window within an aggregation operation.

public class Window<TKey,TSource>

type Window<'Key, 'Source> = class

Public Class Window(Of TKey, TSource)

Type Parameters

TKey

TSource

Inheritance: Object
Window<TKey,TSource>

Derived: Microsoft.StreamProcessing.FilteredWindow<TKey,TSource>

Constructors

Window<TKey,TSource>(Expression<Func<TSource,Boolean>>, StreamProperties<TKey,TSource>)

Creates a new window representation with the given filter and properties.

Fields

Filter

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

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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
CountNotNull<TValue>(Expression<Func<TSource,TValue>>)	Computes a time-sensitive count aggregate of the non-null values using "snapshot windows" (SI terminology).
Max<TValue>(Expression<Func<TSource,TValue>>)	Computes a time-sensitive maximum aggregate using "snapshot windows" (SI terminology).
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.
Max<TValue>(Expression<Func<TSource,TValue>>, IComparerExpression<TValue>)	Computes a time-sensitive maximum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.
Min<TValue>(Expression<Func<TSource,TValue>>)	Computes a time-sensitive minimum aggregate using "snapshot windows" (SI terminology).
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.
Min<TValue>(Expression<Func<TSource,TValue>>, IComparerExpression<TValue>)	Computes a time-sensitive minimum aggregate using "snapshot windows" (SI terminology) with the provided ordering comparer.
PercentileContinuous(Double, Expression<Func<TSource,Double>>)	Computes a percentile continuous aggregate.
PercentileContinuous(Expression<Comparison<Double>>, Double, Expression<Func<TSource,Double>>)	Computes a percentile continuous aggregate.
PercentileDiscrete(Double, Expression<Func<TSource,Double>>)	Computes a percentile discrete aggregate.
PercentileDiscrete(Expression<Comparison<Double>>, Double, Expression<Func<TSource,Double>>)	Computes a percentile discrete aggregate.
PopulationStandardDeviation(Expression<Func<TSource,Nullable<Double>>>)	Computes the population standard deviation of the elements in the window.
PopulationStandardDeviation(Expression<Func<TSource,Nullable<Int64>>>)	Computes the population standard deviation of the elements in the window.
PopulationVariance(Expression<Func<TSource,Nullable<Double>>>)	Computes the population variance of the elements in the window.
PopulationVariance(Expression<Func<TSource,Nullable<Int64>>>)	Computes the population variance of the elements in the window.
Product(Expression<Func<TSource,BigInteger>>)	Computes a time-sensitive product aggregate over BigIntegers using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Byte>>)	Computes a time-sensitive product aggregate over bytes using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Complex>>)	Computes a time-sensitive product aggregate over Complexs using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Decimal>>)	Computes a time-sensitive product aggregate over decimals using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Double>>)	Computes a time-sensitive product aggregate over doubles using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Int16>>)	Computes a time-sensitive product aggregate over shorts using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Int32>>)	Computes a time-sensitive product aggregate over ints using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Int64>>)	Computes a time-sensitive product aggregate over longs using "snapshot windows" (SI terminology).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Product(Expression<Func<TSource,SByte>>)	Computes a time-sensitive product aggregate over sbytes using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,Single>>)	Computes a time-sensitive product aggregate over floats using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,UInt16>>)	Computes a time-sensitive product aggregate over ushorts using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,UInt32>>)	Computes a time-sensitive product aggregate over uints using "snapshot windows" (SI terminology).
Product(Expression<Func<TSource,UInt64>>)	Computes a time-sensitive product aggregate over ulongs using "snapshot windows" (SI terminology).
SingleOrDefault()	Computes a time-sensitive single-or-default aggregate using "snapshot windows" (SI terminology).
StandardDeviation(Expression<Func<TSource,Nullable<Double>>>)	Computes the sample standard deviation of the elements in the window.
StandardDeviation(Expression<Func<TSource,Nullable<Int64>>>)	Computes the sample standard deviation of the elements in the window.
Sum(Expression<Func<TSource,BigInteger>>)	Computes a time-sensitive sum aggregate over BigIntegers using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Byte>>)	Computes a time-sensitive sum aggregate over bytes using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Complex>>)	Computes a time-sensitive sum aggregate over Complexs using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Decimal>>)	Computes a time-sensitive sum aggregate over decimals using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Double>>)	Computes a time-sensitive sum aggregate over doubles using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Int16>>)	Computes a time-sensitive sum aggregate over shorts using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Int32>>)	Computes a time-sensitive sum aggregate over ints using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Int64>>)	Computes a time-sensitive sum aggregate over longs using "snapshot windows" (SI terminology).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Sum(Expression<Func<TSource,SByte>>)	Computes a time-sensitive sum aggregate over sbytes using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,Single>>)	Computes a time-sensitive sum aggregate over floats using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,UInt16>>)	Computes a time-sensitive sum aggregate over ushorts using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,UInt32>>)	Computes a time-sensitive sum aggregate over uints using "snapshot windows" (SI terminology).
Sum(Expression<Func<TSource,UInt64>>)	Computes a time-sensitive sum aggregate over ulongs using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,BigInteger>>)	Computes a time-sensitive sum-squares aggregate over BigIntegers using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Byte>>)	Computes a time-sensitive sum-squares aggregate over bytes using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Complex>>)	Computes a time-sensitive sum-squares aggregate over Complexs using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Decimal>>)	Computes a time-sensitive sum-squares aggregate over decimals using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Double>>)	Computes a time-sensitive sum-squares aggregate over doubles using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Int16>>)	Computes a time-sensitive sum-squares aggregate over shorts using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Int32>>)	Computes a time-sensitive sum-squares aggregate over ints using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Int64>>)	Computes a time-sensitive sum-squares aggregate over longs using "snapshot windows" (SI terminology).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
SumSquares(Expression<Func<TSource,SByte>>)	Computes a time-sensitive sum-squares aggregate over sbytes using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,Single>>)	Computes a time-sensitive sum-squares aggregate over floats using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,UInt16>>)	Computes a time-sensitive sum-squares aggregate over ushorts using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,UInt32>>)	Computes a time-sensitive sum-squares aggregate over uints using "snapshot windows" (SI terminology).
SumSquares(Expression<Func<TSource,UInt64>>)	Computes a time-sensitive sum-squares aggregate over ulongs using "snapshot windows" (SI terminology).
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.
TopK<TOrderValue>(Expression<Func<TSource,TOrderValue>>, Int32)	Computes a time-sensitive top-k aggregate using "snapshot windows" (SI terminology) based on a key selector.
Variance(Expression<Func<TSource,Nullable<Double>>>)	Computes the sample variance of the elements in the window.
Variance(Expression<Func<TSource,Nullable<Int64>>>)	Computes the sample variance of the elements in the window.
Where(Expression<Func<TSource,Boolean>>)	Filter input rows with the specified filter.

Applies to

Share via