Observable.Window<TSource> Method (IObservable<TSource>, TimeSpan, TimeSpan, IScheduler)
Projects each element of an observable sequence into zero or more windows which are produced based on timing information.
Namespace: System.Reactive.Linq
Assembly: System.Reactive (in System.Reactive.dll)
Syntax
'Declaration
<ExtensionAttribute> _
Public Shared Function Window(Of TSource) ( _
source As IObservable(Of TSource), _
timeSpan As TimeSpan, _
timeShift As TimeSpan, _
scheduler As IScheduler _
) As IObservable(Of IObservable(Of TSource))
'Usage
Dim source As IObservable(Of TSource)
Dim timeSpan As TimeSpan
Dim timeShift As TimeSpan
Dim scheduler As IScheduler
Dim returnValue As IObservable(Of IObservable(Of TSource))
returnValue = source.Window(timeSpan, _
timeShift, scheduler)
public static IObservable<IObservable<TSource>> Window<TSource>(
this IObservable<TSource> source,
TimeSpan timeSpan,
TimeSpan timeShift,
IScheduler scheduler
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<IObservable<TSource>^>^ Window(
IObservable<TSource>^ source,
TimeSpan timeSpan,
TimeSpan timeShift,
IScheduler^ scheduler
)
static member Window :
source:IObservable<'TSource> *
timeSpan:TimeSpan *
timeShift:TimeSpan *
scheduler:IScheduler -> IObservable<IObservable<'TSource>>
JScript does not support generic types and methods.
Type Parameters
- TSource
The type of source.
Parameters
- source
Type: System.IObservable<TSource>
The source sequence to produce windows over.
- timeSpan
Type: System.TimeSpan
The length of each window.
- timeShift
Type: System.TimeSpan
The interval between creation of consecutive windows.
- scheduler
Type: System.Reactive.Concurrency.IScheduler
The scheduler to run windowing timers on.
Return Value
Type: System.IObservable<IObservable<TSource>>
An observable sequence of windows.
Usage Note
In Visual Basic and C#, you can call this method as an instance method on any object of type IObservable<TSource>. When you use instance method syntax to call this method, omit the first parameter. For more information, see or .
Remarks
The Window operator breaks a source sequence into buffered subsets like a windowed view of the sequence. The timeSpan parameter controls how many items are placed in each window buffer by keeping the window open for the duration of that time span. The timeShift parameter indicates the time span, from the beginning of the previous window, which must complete before a new window opens. This shifts the view into the sequence based on the duration of that time span. The scheduler parameter controls where to run the timers associated with the timeSpan and timeShift parameters.
Examples
In this example the Window operator is used to observe integer sequences from the Interval operator every second.. Each integer sequence is viewed through a window. Each window will be open for 2.5 seconds and then closed. The timeShift parameter is set to 5 seconds . This means a new window will open every 5 seconds from the time each previous window opened. The end result is we have a window open for 2.5 seconds and then closed for 2.5 seconds. So the sequences will include two integers starting from every 5th integer beginning with 0.
using System;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
namespace Example
{
class Program
{
static void Main()
{
//**********************************************************************************************//
//*** The mainSequence produces a new long integer from the Interval operator every sec but ***//
//*** this sequence is broken up by the Window operator into subsets like a windowed ***//
//*** view of the sequence. ***//
//*** ***//
//*** The timeSpan parameter controls how many items are placed in each window buffer by ***//
//*** keeping the window open for the duration of the time span. ***//
//*** ***//
//*** The timeShift parameter indicates the time span which must complete before a new ***//
//*** window opens. This shifts the view into the sequence based on the duration of the time ***//
//*** span. ***//
//*** ***//
//*** The ThreadPool scheduler is used to run the timers on a .NET thread pool thread. This ***//
//*** prevents the main thread from being blocked so pressing enter can exit the example. ***//
//*** ***//
//*** In this example each window will be open for 2.5 seconds. This will allow each window ***//
//*** to hold some items from the sequence starting with the first item (0). Then the ***//
//*** timeShift parameter shifts the next window opening by 5 seconds from the beginning of ***//
//*** the previous window. The result is that a window is open for 2.5 seconds then closed ***//
//*** for 2.5 seconds. ***//
//**********************************************************************************************//
var mainSequence = Observable.Interval(TimeSpan.FromSeconds(1));
TimeSpan timeSpan = TimeSpan.FromSeconds(2.5);
TimeSpan timeShift = TimeSpan.FromSeconds(5);
var seqWindowed = mainSequence.Window(timeSpan, timeShift, Scheduler.ThreadPool);
//*********************************************************************************************//
//*** A subscription to seqWindowed will provide a new IObservable<long> for some items in ***//
//*** the main sequence starting with the first item. Then we will receive a new observable ***//
//*** for every window. ***//
//*** ***//
//*** Create a subscription to each window into the main sequence and list the values. ***//
//*********************************************************************************************//
Console.WriteLine("Creating the subscription. Press ENTER to exit...\n");
seqWindowed.Subscribe(seqWindow =>
{
Console.WriteLine("\nA new window into the main sequence has been opened\n");
seqWindow.Subscribe(x =>
{
Console.WriteLine("Integer : {0}", x);
});
});
Console.ReadLine();
}
}
}
The following output was generated by the example code.
Creating the subscription. Press ENTER to exit...
A new window into the main sequence has been opened
Integer : 0
Integer : 1
A new window into the main sequence has been opened
Integer : 5
Integer : 6
A new window into the main sequence has been opened
Integer : 10
Integer : 11
A new window into the main sequence has been opened
Integer : 15
Integer : 16
A new window into the main sequence has been opened
Integer : 20
Integer : 21