Observable.Window<TSource> , méthode (IObservable<TSource>, Int32, Int32)
Projette chaque élément d’une séquence observable en une ou plusieurs fenêtres produites en fonction des informations de nombre d’éléments.
Espace de noms :System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- TSource
Type de la source.
Paramètres
- source
Type : System.IObservable<TSource>
Séquence source sur laquelle produire des fenêtres.
- count
Type : System.Int32
Longueur de chaque fenêtre.
- skip
Type : System.Int32
Nombre d’éléments à ignorer entre la création de fenêtres consécutives.
Valeur de retour
Type : System.IObservable<IObservable<TSource>>
Séquence observable de fenêtres.
Remarque sur l'utilisation
En Visual Basic et C#, vous pouvez appeler cette méthode en tant que méthode instance sur n’importe quel objet de type IObservable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez ou .
Notes
L’opérateur Window peut être utilisé pour diviser une séquence en sous-ensembles mis en mémoire tampon, comme une vue fenêtré de la séquence. Le paramètre count contrôle le nombre d’éléments placés dans chaque fenêtre. Le paramètre skip contrôle lorsque la fenêtre suivante démarre en comptant les éléments produits dans la séquence main. Lorsque le nombre d’éléments spécifié est ignoré, une nouvelle fenêtre commence à mettre en mémoire tampon un sous-ensemble de la séquence.
Exemples
Cet exemple génère une séquence main d’entiers à l’aide de l’opérateur Interval. Un nouvel entier est produit toutes les secondes. La séquence main est divisée par l’opérateur Window en sous-ensembles, comme une vue fenêtré de la séquence entière. Chaque fenêtre contient un nombre de trois éléments de la séquence commençant par le premier élément (0). Ensuite, cinq éléments sont ignorés afin que nous obtenions des fenêtres dans la séquence d’entiers qui contient trois entiers. Chaque fenêtre commence par chaque 5e entier commençant par 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();
}
}
}
La sortie suivante a été générée avec l’exemple de code.
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