Método TSource Observable.Window<(IObservable<TSource>, TimeSpan, TimeSpan, IScheduler)>
Projeta cada elemento de uma sequência observável em zero ou mais janelas que são produzidas com base nas informações de tempo.
Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)
Sintaxe
'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.
Parâmetros de tipo
- TSource
O tipo de fonte.
Parâmetros
- source
Tipo: System.IObservable<TSource>
A sequência de origem para produzir janelas.
- timeSpan
Tipo: System.TimeSpan
O comprimento de cada janela.
- Timeshift
Tipo: System.TimeSpan
O intervalo entre a criação de janelas consecutivas.
- agendador
Tipo: System.Reactive.Concurrency.IScheduler
O agendador no qual executar temporizadores de janela.
Valor Retornado
Tipo: System.IObservable<IObservable<TSource>>
Uma sequência observável de janelas.
Observação de uso
No Visual Basic e no C#, você pode chamar esse método como um método de instância em qualquer objeto do tipo IObservable<TSource>. Quando você usar a sintaxe de método de instância para chamar esse método, omita o primeiro parâmetro. Para obter mais informações, consulte ou .
Comentários
O operador Window divide uma sequência de origem em subconjuntos armazenados em buffer como uma exibição em janelas da sequência. O parâmetro timeSpan controla quantos itens são colocados em cada buffer de janela mantendo a janela aberta durante esse período de tempo. O parâmetro timeShift indica o intervalo de tempo, desde o início da janela anterior, que deve ser concluído antes que uma nova janela seja aberta. Isso desloca a exibição para a sequência com base na duração desse período de tempo. O parâmetro scheduler controla onde executar os temporizadores associados aos parâmetros timeSpan e timeShift.
Exemplos
Neste exemplo, o operador Window é usado para observar sequências de inteiros do operador Interval a cada segundo.. Cada sequência de inteiros é exibida por meio de uma janela. Cada janela ficará aberta por 2,5 segundos e, em seguida, será fechada. O parâmetro timeShift é definido como 5 segundos. Isso significa que uma nova janela será aberta a cada 5 segundos a partir do momento em que cada janela anterior for aberta. O resultado final é que temos uma janela aberta por 2,5 segundos e depois fechada por 2,5 segundos. Portanto, as sequências incluirão dois inteiros a partir de cada 5º inteiro começando com 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();
}
}
}
A saída a seguir foi gerada pelo código de exemplo.
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