Método TSource Observable.Window<(IObservable<TSource>, Int32, Int32)>
Projeta cada elemento de uma sequência observável em zero ou mais janelas que são produzidas com base nas informações de contagem de elementos.
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), _
count As Integer, _
skip As Integer _
) As IObservable(Of IObservable(Of TSource))
'Usage
Dim source As IObservable(Of TSource)
Dim count As Integer
Dim skip As Integer
Dim returnValue As IObservable(Of IObservable(Of TSource))
returnValue = source.Window(count, _
skip)
public static IObservable<IObservable<TSource>> Window<TSource>(
this IObservable<TSource> source,
int count,
int skip
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<IObservable<TSource>^>^ Window(
IObservable<TSource>^ source,
int count,
int skip
)
static member Window :
source:IObservable<'TSource> *
count:int *
skip:int -> 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.
- count
Tipo: System.Int32
O comprimento de cada janela.
- skip
Tipo: System.Int32
O número de elementos a serem ignoradas entre a criação de janelas consecutivas.
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 pode ser usado para dividir uma sequência em subconjuntos armazenados em buffer, como uma exibição em janelas da sequência. O parâmetro count controla quantos itens são colocados em cada janela. O parâmetro skip controla quando a próxima janela é iniciada contando os itens produzidos na sequência de main. Quando o número especificado de itens é ignorado, uma nova janela começa a armazenar em buffer um subconjunto da sequência.
Exemplos
Este exemplo produz uma sequência main de inteiros usando o operador Interval. Um novo inteiro é produzido a cada segundo. A sequência main é dividida pelo operador Window em subconjuntos como uma exibição em janelas da sequência de inteiros. Cada janela conterá uma contagem de três itens da sequência começando com o primeiro item (0). Em seguida, cinco itens são ignorados para que possamos obter janelas na sequência de inteiros que contêm três inteiros. Cada janela começa com cada 5º inteiro começando em 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 second ***//
//*** but this sequence is broken up by the Window operator into subsets like a windowed ***//
//*** view of the sequence. The count parameter controls how many items are placed in each ***//
//*** window. The skip parameter controls when the next window starts by counting the items ***//
//*** produced in the main sequence. When the the specified number of items are skipped, a ***//
//*** new window starts. ***//
//*** ***//
//*** In this example each window will contain a count of 3 items from the sequence starting ***//
//*** with the first item (0). 5 items are "skipped" to determine when the next window opens. ***//
//*** So the result is that the integer sequences in the windows start with every 5th integer ***//
//*** beginning at 0 and include 3 integers. ***//
//***********************************************************************************************//
var mainSequence = Observable.Interval(TimeSpan.FromSeconds(1));
int count = 3;
int skip = 5;
var seqWindowed = mainSequence.Window(count, skip);
//*********************************************************************************************//
//*** A subscription to seqWindowed will provide a new IObservable<long> for every 5th item ***//
//*** in the main sequence starting with the first item. ***//
//*** ***//
//*** Create a subscription to each window into the main sequence and list the value. ***//
//*********************************************************************************************//
Console.WriteLine("\nCreating 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 com o 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
Integer : 2
A new window into the main sequence has been opened
Integer : 5
Integer : 6
Integer : 7
A new window into the main sequence has been opened
Integer : 10
Integer : 11
Integer : 12
A new window into the main sequence has been opened
Integer : 15
Integer : 16
Integer : 17