共用方式為


Observable.Throttle < TSource > 方法 (IObservable < TSource > 、TimeSpan、IScheduler)

忽略可觀察序列中的值,後面接著另一個值,然後才有指定的來源 dueTime 和 scheduler。

Namespace:System.Reactive.Linq
裝配: System.Reactive.dll) 中的 System.Reactive (

Syntax

'Declaration
<ExtensionAttribute> _
Public Shared Function Throttle(Of TSource) ( _
    source As IObservable(Of TSource), _
    dueTime As TimeSpan, _
    scheduler As IScheduler _
) As IObservable(Of TSource)
'Usage
Dim source As IObservable(Of TSource)
Dim dueTime As TimeSpan
Dim scheduler As IScheduler
Dim returnValue As IObservable(Of TSource)

returnValue = source.Throttle(dueTime, _
    scheduler)
public static IObservable<TSource> Throttle<TSource>(
    this IObservable<TSource> source,
    TimeSpan dueTime,
    IScheduler scheduler
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<TSource>^ Throttle(
    IObservable<TSource>^ source, 
    TimeSpan dueTime, 
    IScheduler^ scheduler
)
static member Throttle : 
        source:IObservable<'TSource> * 
        dueTime:TimeSpan * 
        scheduler:IScheduler -> IObservable<'TSource> 
JScript does not support generic types and methods.

類型參數

  • TSource
    來源的類型。

參數

  • dueTime
    類型: System.TimeSpan
    每個值的節流期間持續時間。

傳回值

類型:System.IObservable< TSource>
可觀察序列中的值,後面接著另一個值,然後再到期。

使用注意事項

在 Visual Basic 和 C# 中,您可以在IObservable< TSource > 類型的任何物件上呼叫這個方法作為實例方法。 使用執行個體方法語法呼叫這個方法時,請省略第一個參數。 如需詳細資訊,請參閱

備註

Throttle 運算子會從序列緩衝專案,並等候 dueTime 參數所指定的時間範圍到期。 如果在時間範圍到期之前序列中產生另一個專案,則該專案會取代緩衝區中的舊專案,而等候會重新開始。 如果到期時間在序列中產生另一個專案之前到期,則會透過序列的任何訂用帳戶來觀察該專案。

範例

此範例示範如何使用節流運算子,保證在間隔內觀察到專案的速度不超過兩秒。 這會示範如何使用LessBarrageOfEmails 方法來持續產生以可觀察序列中的專案的形式產生的電子郵件。 序列中的電子郵件專案會在彼此的三秒內以隨機間隔發生。 只會從序列觀察到在後兩個時間範圍之後沒有專案的專案。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Reactive.Linq;
using System.Reactive.Concurrency;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*****************************************************************************************************//
      //*** Create an observable sequence from the enumerator which is yielding random emails within      ***//
      //*** 3 sec. continuously.  The enumeration of the enumerator will be scheduled to run on a thread  ***//
      //*** in the .NET thread pool so the main thread will not be blocked.                               ***//
      //*****************************************************************************************************//

      var obs = EndlessBarrageOfEmails().ToObservable(Scheduler.ThreadPool);


      //****************************************************************************************************//
      //*** Use the throttle operator to ONLY deliver an item that occurs with a 2 second interval       ***//
      //*** between it and the next item in the sequence. The throttle buffer will hold an item from the ***//
      //*** sequence waiting for the 2 second timespan to pass. If a new item is produced before the     ***//
      //*** time span expires, that new item will replace the old item in the buffer and the wait starts ***//
      //*** over. If the time span does expire before a new item is produced, then the item in the       ***//
      //*** buffer will be observed through any subscriptions on the sequence.                           ***//
      //***                                                                                              ***//
      //*** To be clear, an item is not guarnteed to be returned every 2 seconds. The use of throttle    ***//
      //*** here does guarntee that the subscriber will observe an item no faster than every 2 sec.      ***//
      //***                                                                                              ***//
      //*** Since a new email is generated at a random time within 3 seconds, the items which are        ***//
      //*** generated with 2 seconds of silence following them will also be random.                      ***//
      //***                                                                                              ***//
      //*** The timers associated with the 2 second time span are run on the .NET thread pool.           ***//
      //****************************************************************************************************//

      var obsThrottled = obs.Throttle(TimeSpan.FromSeconds(2), Scheduler.ThreadPool);


      //***********************************************************************************************//
      //*** Write each observed email to the console window. Also write a current timestamp to get  ***//
      //*** an idea of the time which has passed since the last item was observed. Notice, the time ***//
      //*** will not be less than 2 seconds but, will frequently exceed 2 sec.                      ***//
      //***********************************************************************************************//

      obsThrottled.Subscribe(i => Console.WriteLine("{0}\nTime Received {1}\n", i, DateTime.Now.ToString()));


      //*********************************************************************************************//
      //*** Main thread waiting on the user's ENTER key press.                                    ***//
      //*********************************************************************************************//

      Console.WriteLine("\nPress ENTER to exit...\n");
      Console.ReadLine();
    }




    //*********************************************************************************************//
    //***                                                                                       ***//
    //*** This method will continually yield a random email at a random interval within 3 sec.  ***//
    //***                                                                                       ***//
    //*********************************************************************************************//
    static IEnumerable<string> EndlessBarrageOfEmails()
    {
      Random random = new Random();

      //***************************************************************//
      //*** For this example we are using this fixed list of emails ***//
      //***************************************************************//
      List<string> emails = new List<string> { "Email Msg from John ", 
                                               "Email Msg from Bill ", 
                                               "Email Msg from Marcy ", 
                                               "Email Msg from Wes "};

      //***********************************************************************************//
      //*** Yield an email from the list continually at a random interval within 3 sec. ***//
      //***********************************************************************************//
      while (true)
      {
        yield return emails[random.Next(emails.Count)];
        Thread.Sleep(random.Next(3000));
      }
    }
  }
}

下列輸出是從範例程式碼產生。

Press ENTER to exit...

Email Msg from Wes
Time Received 6/5/2011 11:54:05 PM

Email Msg from Marcy
Time Received 6/5/2011 11:54:08 PM

Email Msg from Bill
Time Received 6/5/2011 11:54:12 PM

Email Msg from Bill
Time Received 6/5/2011 11:54:15 PM

Email Msg from John
Time Received 6/5/2011 11:54:33 PM

Email Msg from Wes
Time Received 6/5/2011 11:54:35 PM

Email Msg from Marcy
Time Received 6/5/2011 11:54:38 PM

Email Msg from Bill
Time Received 6/5/2011 11:54:43 PM

另請參閱

參考

Observable 類別

節流多載

System.Reactive.Linq 命名空間