Método Observable.Interval (TimeSpan, IScheduler)

Artigo
06/28/2011

Retorna uma sequência observável que produz um valor após cada período.

Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)

Sintaxe

'Declaration
Public Shared Function Interval ( _
    period As TimeSpan, _
    scheduler As IScheduler _
) As IObservable(Of Long)

'Usage
Dim period As TimeSpan
Dim scheduler As IScheduler
Dim returnValue As IObservable(Of Long)

returnValue = Observable.Interval(period, _
    scheduler)

public static IObservable<long> Interval(
    TimeSpan period,
    IScheduler scheduler
)

public:
static IObservable<long long>^ Interval(
    TimeSpan period, 
    IScheduler^ scheduler
)

static member Interval : 
        period:TimeSpan * 
        scheduler:IScheduler -> IObservable<int64>

public static function Interval(
    period : TimeSpan, 
    scheduler : IScheduler
) : IObservable<long>

Parâmetros

period
Tipo: System.TimeSpan
O período para produzir os valores na sequência resultante.

agendador
Tipo: System.Reactive.Concurrency.IScheduler
O agendador no qual executar o temporizador.

Valor Retornado

Tipo: System.IObservable<Int64>
Uma sequência observável que produz um valor após cada período.

Comentários

O operador Interval gera uma sequência de inteiros longos. Cada inteiro é gerado após o período de tempo fornecido para o parâmetro de período expirar. O parâmetro agendador pode ser usado para agendar a geração de inteiros usando qualquer um dos agendadores fornecidos ou um agendador personalizado. Por exemplo , o NewThreadScheduler pode ser usado para executar a geração dos inteiros em um novo thread.

Exemplos

O código de exemplo a seguir usa o operador Interval para gerar uma sequência de inteiros longos olhando para zero. Cada inteiro na sequência é gerado após o término do segundo período. Cada inteiro é gravado na janela do console junto com a hora atual para mostrar o parâmetro de período em vigor. A geração da sequência de inteiros está agendada para ser executada em um thread do pool de threads do .Net para que o thread do main não seja bloqueado e possa processar a tecla enter que está sendo pressionada para interromper o intervalo.

using System;
using System.Reactive.Linq;
using System.Reactive.Concurrency;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************************************************************//
      //*** Generate a sequence of integers starting at zero until ENTER is pressed.              ***//
      //***                                                                                       ***//
      //*** A new integer will be generated by the Interval operator after each 2 second period   ***//
      //*** expires.                                                                              ***//
      //***                                                                                       ***//
      //*** By using the ThreadPool scheduler, the sequence of integers will be generated by a    ***//
      //*** thread in the .NET thread so the main thread is not blocked.                          ***//
      //*********************************************************************************************//

      const int periodInSec = 2;
      var obs = Observable.Interval(TimeSpan.FromSeconds(periodInSec),
                                    Scheduler.ThreadPool);


      //*********************************************************************************************//
      //*** Write each value from Interval to the console window along with the current time to   ***//
      //*** show the period time span in effect.                                                  ***//
      //*********************************************************************************************//

      using (IDisposable handle = obs.Subscribe(x => Console.WriteLine("Integer : {0}\tCurrent Time : {1}", x, DateTime.Now.ToLongTimeString())))
      {
        Console.WriteLine("Press ENTER to exit...\n");
        Console.ReadLine();
      }
    }
  }
}

A saída a seguir foi gerada pelo código de exemplo.

Press ENTER to exit...

Integer : 0     Current Time : 5:11:55 PM
Integer : 1     Current Time : 5:11:57 PM
Integer : 2     Current Time : 5:11:59 PM
Integer : 3     Current Time : 5:12:01 PM
Integer : 4     Current Time : 5:12:03 PM
Integer : 5     Current Time : 5:12:05 PM
Integer : 6     Current Time : 5:12:07 PM
Integer : 7     Current Time : 5:12:09 PM
Integer : 8     Current Time : 5:12:11 PM
Integer : 9     Current Time : 5:12:13 PM
Integer : 10    Current Time : 5:12:15 PM
Integer : 11    Current Time : 5:12:17 PM
Integer : 12    Current Time : 5:12:19 PM
Integer : 13    Current Time : 5:12:21 PM

Consulte Também

Referência

Classe Observável

Sobrecarga de intervalo

System.Reactive.Linq Namespace

Compartilhar via