Sdílet prostřednictvím

Observable.Window<TSource> – metoda (IObservable<TSource>, Int32, Int32)

  • Článek

Promítá každý prvek pozorovatelné sekvence do nula nebo více oken, která jsou vytvořena na základě informací o počtu prvků.

Obor názvů:System.Reactive.Linq
Sestavení: System.Reactive (v 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.

Parametry typu

  • Tsource
    Typ zdroje.

Parametry

  • Přeskočit
    Typ: System.Int32
    Počet prvků, které se mají přeskočit mezi vytvořením po sobě jdoucích oken.

Návratová hodnota

Typ: System.IObservable<IObservable<TSource>>
Pozorovatelná posloupnost oken.

Poznámka k využití

V jazyce Visual Basic a C# můžete tuto metodu volat jako metodu instance u libovolného objektu typu IObservable<TSource>. Pokud k volání této metody použijete syntaxi metody instance, vynechejte první parametr. Další informace naleznete v tématech a .

Poznámky

Operátor Window lze použít k rozdělení sekvence na podmnožinu s vyrovnávací pamětí, jako je zobrazení sekvence v okně. Parametr count určuje, kolik položek se umístí do každého okna. Parametr skip řídí při zahájení dalšího okna počítá položky vytvořené v hlavní sekvenci. Při přeskočení zadaného počtu položek začne nové okno ukládat do vyrovnávací paměti podmnožinu sekvence.

Příklady

Tento příklad vytvoří hlavní sekvenci celých čísel pomocí operátoru Interval. Nové celé číslo se vytvoří každou sekundu. Hlavní sekvence je rozdělena operátorem Okno na podmnožinu, jako je zobrazení celé sekvence v okně. Každé okno bude obsahovat počet tří položek ze sekvence počínaje první položkou (0). Poté se přeskočí pět položek, abychom získali okna do celočíselné sekvence, která obsahuje tři celá čísla. Každé okno začíná každým 5. číslem počínaje číslem 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();
    }
  }
}

Následující výstup byl vygenerován s ukázkovým kódem.

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

Viz také

Reference

Pozorovatelná třída

Přetížení okna

System.Reactive.Linq – obor názvů