忽略可观测序列中的值,这些值后跟指定源、dueTime 和计划程序到期前的另一个值。
              Namespace:System.Reactive.Linq
              装配: System.Reactive.dll) 中的 System.Reactive (
语法
'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
源的类型。 
parameters
- source
类型: System.IObservable<TSource>
要限制的源序列。 
- dueTime
类型: System.TimeSpan
每个值的限制期的持续时间。 
- scheduler
类型: System.Reactive.Concurrency.IScheduler
要运行限制计时器的计划程序。 
返回值
类型: System.IObservable<TSource>
可观测序列中的值,这些值在到期前后跟另一个值。
使用说明
在 Visual Basic 和 C# 中,可以将此方法作为 IObservable<TSource> 类型的任何对象的实例方法调用。 当使用实例方法语法调用此方法时,请省略第一个参数。 有关详细信息,请参阅或。
备注
Throttle 运算符缓冲序列中的项,并等待 dueTime 参数指定的时间跨度过期。 如果在时间跨度过期之前从序列中生成了另一项,则该项将替换缓冲区中的旧项,等待将重新开始。 如果到期时间确实在序列中生成另一项之前过期,则通过序列的任何订阅来观察该项。
示例
此示例演示如何使用限制运算符来保证以不超过两秒的间隔观察项。 这是通过使用 EndlessBarrageOfEmails 方法持续生成以可观察序列中的项目生成的电子邮件来演示的。 序列中的电子邮件项在三秒内以随机间隔出现。 仅从序列中观察在两个时间跨度内没有项目之后发生的项。
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