Observable.Window<TSource, Método TWindowClosing> (IObservable<TSource>, Func<IObservable<TWindowClosing>>)
Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas.
Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)
Sintaxe
'Declaration
<ExtensionAttribute> _
Public Shared Function Window(Of TSource, TWindowClosing) ( _
source As IObservable(Of TSource), _
windowClosingSelector As Func(Of IObservable(Of TWindowClosing)) _
) As IObservable(Of IObservable(Of TSource))
'Usage
Dim source As IObservable(Of TSource)
Dim windowClosingSelector As Func(Of IObservable(Of TWindowClosing))
Dim returnValue As IObservable(Of IObservable(Of TSource))
returnValue = source.Window(windowClosingSelector)
public static IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(
this IObservable<TSource> source,
Func<IObservable<TWindowClosing>> windowClosingSelector
)
[ExtensionAttribute]
public:
generic<typename TSource, typename TWindowClosing>
static IObservable<IObservable<TSource>^>^ Window(
IObservable<TSource>^ source,
Func<IObservable<TWindowClosing>^>^ windowClosingSelector
)
static member Window :
source:IObservable<'TSource> *
windowClosingSelector:Func<IObservable<'TWindowClosing>> -> IObservable<IObservable<'TSource>>
JScript does not support generic types and methods.
Parâmetros de tipo
- TSource
O tipo de fonte.
- TWindowClosing
O tipo de fechamento da janela.
Parâmetros
- source
Tipo: System.IObservable<TSource>
A sequência de origem para produzir janelas.
- windowClosingSelector
Tipo: System.Func<IObservable<TWindowClosing>>
Uma função invocada para definir os limites das janelas produzidas.
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 observável em janelas consecutivas não sobrepostas. O final da janela atual e o início da próxima janela são controlados por uma sequência observável que é o resultado da função windowClosingSelect que é passada como um parâmetro de entrada para o operador . O operador pode ser usado para agrupar um conjunto de eventos em uma janela. Por exemplo, os estados de uma transação podem ser a sequência de main que está sendo observada. Esses estados podem incluir: Preparando, Preparado, Ativo e Confirmado/Anulado. A sequência de main pode incluir todos esses estados se eles ocorrerem nessa ordem. A função windowClosingSelect pode retornar uma sequência observável que produz apenas um valor nos estados Committed ou Abort. Isso fecharia a janela que representava eventos de transação para uma transação específica.
Exemplos
O exemplo simples a seguir divide uma sequência de inteiros em janelas consecutivas não sobrepostas. O final da janela atual e o início da próxima janela são controlados por uma sequência observável de inteiros produzidos pelo operador Interval a cada seis segundos. Como o main sequência observável está produzindo um item a cada segundos, cada janela terá seis itens. O código de exemplo grava cada janela de inteiros na janela do console junto com um carimbo de data/hora que mostra que uma nova janela é aberta a cada seis segundos.
using System;
using System.Reactive.Linq;
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 time when each window stops and the next window starts is ***//
//*** controlled by the IObservable<TWindowClosing> named seqWindowControl. It is returned ***//
//*** by the lambda expression which is passed to the Window operator. In this case it ***//
//** returns another IObservable<long> generated by the Interval operator. So whenever ***//
//*** seqWindowControl produces a item, the current window into the mainSequence stops and ***//
//*** a new window starts. ***//
//*********************************************************************************************//
var mainSequence = Observable.Interval(TimeSpan.FromSeconds(1));
var seqWindowed = mainSequence.Window(() =>
{
var seqWindowControl = Observable.Interval(TimeSpan.FromSeconds(6));
return seqWindowControl;
});
//*********************************************************************************************//
//*** A subscription to seqWindowed will provide a new IObservable<long> every 6 secs. ***//
//*** ***//
//*** Create a subscription to each window into the main sequence and list the values along ***//
//*** with the time the window was opened and the previous window was closed. ***//
//*********************************************************************************************//
seqWindowed.Subscribe(seqWindow =>
{
Console.WriteLine("\nA new window into the main sequence has opened: {0}\n",DateTime.Now.ToString());
seqWindow.Subscribe(x =>
{
Console.WriteLine("Integer : {0}", x);
});
});
Console.ReadLine();
}
}
}
A saída a seguir foi gerada pelo código de exemplo.
A new window into the main sequence has opened: 6/1/2011 8:48:43 PM
Integer : 0
Integer : 1
Integer : 2
Integer : 3
Integer : 4
Integer : 5
A new window into the main sequence has opened: 6/1/2011 8:48:49 PM
Integer : 6
Integer : 7
Integer : 8
Integer : 9
Integer : 10
Integer : 11
A new window into the main sequence has opened: 6/1/2011 8:48:55 PM
Integer : 12
Integer : 13
Integer : 14
Integer : 15
Integer : 16
Integer : 17
A new window into the main sequence has opened: 6/1/2011 8:49:02 PM
Integer : 18
Integer : 19
Integer : 20
Integer : 21
Integer : 22
Integer : 23