Observable.Window<TSource> , méthode (IObservable<TSource>, TimeSpan, TimeSpan, IScheduler)
Projette chaque élément d’une séquence observable dans zéro ou plusieurs fenêtres produites en fonction des informations de minutage.
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), _
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.
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.
- timeSpan
Type : System.TimeSpan
Longueur de chaque fenêtre.
- Timeshift
Type : System.TimeSpan
Intervalle entre la création de fenêtres consécutives.
- scheduler
Type : System.Reactive.Concurrency.IScheduler
Planificateur sur lequel exécuter les minuteurs de fenêtrage.
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 décompose une séquence source en sous-ensembles mis en mémoire tampon, comme une vue fenêtré de la séquence. Le paramètre timeSpan contrôle le nombre d’éléments placés dans chaque mémoire tampon de fenêtre en conservant la fenêtre ouverte pendant la durée de cet intervalle de temps. Le paramètre timeShift indique l’intervalle de temps, à partir du début de la fenêtre précédente, qui doit se terminer avant qu’une nouvelle fenêtre s’ouvre. Cela déplace la vue dans la séquence en fonction de la durée de cet intervalle de temps. Le paramètre scheduler contrôle où exécuter les minuteurs associés aux paramètres timeSpan et timeShift.
Exemples
Dans cet exemple, l’opérateur Window est utilisé pour observer les séquences d’entiers de l’opérateur Interval toutes les secondes.. Chaque séquence d’entiers est vue par le biais d’une fenêtre. Chaque fenêtre sera ouverte pendant 2,5 secondes, puis fermée. Le paramètre timeShift est défini sur 5 secondes . Cela signifie qu’une nouvelle fenêtre s’ouvre toutes les 5 secondes à partir de l’ouverture de chaque fenêtre précédente. Le résultat final est que nous avons une fenêtre ouverte pendant 2,5 secondes, puis fermée pendant 2,5 secondes. Ainsi, les séquences incluront deux entiers à partir de 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 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();
}
}
}
La sortie suivante a été générée par 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
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