Observable.Throttle<TSource,> méthode (IObservable<TSource>, TimeSpan, IScheduler)
Ignore les valeurs d’une séquence observable qui sont suivies d’une autre valeur avant l’échéance avec la source, dueTime et le planificateur spécifiés.
Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- TSource
Type de la source.
Paramètres
- source
Type : System.IObservable<TSource>
Séquence source à limiter.
- dueTime
Type : System.TimeSpan
Durée de la période de limitation pour chaque valeur.
- scheduler
Type : System.Reactive.Concurrency.IScheduler
Planificateur sur lequel exécuter les minuteurs de limitation.
Valeur de retour
Type : System.IObservable<TSource>
Valeurs d’une séquence observable qui sont suivies d’une autre valeur avant l’échéance.
Remarque sur l'utilisation
Dans Visual Basic et C#, vous pouvez appeler cette méthode en tant que méthode instance sur n’importe quel objet de type IObservable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez ou .
Notes
L’opérateur Throttle met en mémoire tampon un élément de la séquence et attend que l’intervalle de temps spécifié par le paramètre dueTime expire. Si un autre élément est généré à partir de la séquence avant l’expiration de l’intervalle de temps, cet élément remplace l’ancien élément dans la mémoire tampon et l’attente recomment. Si le délai d’échéance expire avant qu’un autre élément ne soit produit dans la séquence, celui-ci est observé via tous les abonnements à la séquence.
Exemples
Cet exemple illustre l’utilisation de l’opérateur de limitation pour garantir que les éléments sont observés à un intervalle inférieur à deux secondes. Cela est illustré par l’utilisation de la méthode EndlessBarrageOfEmails pour générer en continu des e-mails produits en tant qu’éléments dans une séquence observable. Les éléments d’e-mail de la séquence se produisent à intervalles aléatoires dans les trois secondes les uns des autres. Seuls les éléments qui se produisent sans élément suivant pendant les deux secondes sont observés à partir de la séquence.
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));
}
}
}
}
La sortie suivante a été générée à partir de l’exemple de code.
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