Observable.Window<TSource-Methode> (IObservable<TSource>, Int32, Int32)
Projiziert jedes Element einer beobachtbaren Sequenz in 0 oder mehr Fenster, die basierend auf Elementanzahlsinformationen erstellt werden.
Namespace:System.Reactive.Linq
Versammlung: System.Reaktiv (in System.Reactive.dll)
Syntax
'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.
Typparameter
- TSource
Der Quellentyp.
Parameter
- source
Typ: System.IObservable<TSource>
Die Quellsequenz zum Erstellen von Fenstern.
- count
Typ: System.Int32
Die Länge jedes Fensters.
- skip
Typ: System.Int32
Die Anzahl der Elemente, die zwischen der Erstellung aufeinanderfolgender Fenster übersprungen werden sollen.
Rückgabewert
Typ: System.IObservable<IObservable<TSource>>
Eine beobachtbare Sequenz von Fenstern.
Hinweis zur Verwendung
In Visual Basic und C# können Sie diese Methode als instance-Methode für jedes Objekt vom Typ IObservable<TSource> aufrufen. Bei Verwendung der Syntax für Instanzenmethoden lassen Sie den ersten Parameter aus. Weitere Informationen finden Sie unter oder .
Bemerkungen
Der Window-Operator kann verwendet werden, um eine Sequenz in gepufferte Teilmengen aufzuteilen, z. B. eine Fensteransicht der Sequenz. Der Count-Parameter steuert, wie viele Elemente in jedem Fenster platziert werden. Der Skip-Parameter steuert, wenn das nächste Fenster beginnt, indem die in der Standard Sequenz erzeugten Elemente gezählt werden. Wenn die angegebene Anzahl von Elementen übersprungen wird, beginnt ein neues Fenster, eine Teilmenge der Sequenz zu puffern.
Beispiele
In diesem Beispiel wird mithilfe des Interval-Operators eine Standard Sequenz von ganzen Zahlen erzeugt. Jede Sekunde wird eine neue ganze Zahl erstellt. Die Standard Sequenz wird vom Window-Operator in Teilmengen unterteilt, z. B. eine Fensteransicht der Ganzzahlsequenz. Jedes Fenster enthält eine Anzahl von drei Elementen aus der Sequenz ab dem ersten Element (0). Dann werden fünf Elemente übersprungen, sodass Fenster in die ganzzahlige Sequenz gelangen, die drei ganze Zahlen enthalten. Jedes Fenster beginnt mit jeder 5. ganzzahligen Zahl, die bei 0 beginnt.
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();
}
}
}
Die folgende Ausgabe wurde mit dem Beispielcode generiert.
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