Observable.Throttle<TSource> – metoda (IObservable<TSource>, TimeSpan, IScheduler)
Ignoruje hodnoty z pozorovatelné sekvence, po kterých následuje jiná hodnota před termínem splnění se zadaným zdrojem, dueTime a plánovačem.
Obor názvů:System.Reactive.Linq
Sestavení: System.Reactive (v System.Reactive.dll)
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.
Parametry typu
- Tsource
Typ zdroje.
Parametry
- source
Typ: System.IObservable<TSource>
Zdrojová sekvence, která má být omezena.
- Duetime
Typ: System.TimeSpan
Doba trvání období omezení pro každou hodnotu.
- scheduler
Typ: System.Reactive.Concurrency.IScheduler
Plánovač, ve který se mají časovače omezení spustit.
Návratová hodnota
Typ: System.IObservable<TSource>
Hodnoty z pozorovatelné sekvence, za nimiž následuje jiná hodnota před termínem splnění.
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 Throttle vytvoří položku ze sekvence ve vyrovnávací paměti a počká na vypršení časového rozsahu určeného parametrem dueTime. Pokud je ze sekvence vytvořena jiná položka před vypršením časového rozsahu, nahradí tato položka starou položku ve vyrovnávací paměti a čekání začne znovu. Pokud čas splnění vyprší před vytvořením další položky v pořadí, je tato položka pozorována prostřednictvím všech odběrů sekvence.
Příklady
Tento příklad ukazuje použití operátoru omezení k zajištění, že položky jsou pozorovány v intervalu ne rychleji než dvě sekundy. To je demonstrováno pomocí Metody EndlessBarrageOfEmails k průběžnému získávání e-mailů, které jsou vytvořeny jako položky v pozorovatelné sekvenci. E-mailové položky v sekvenci se od sebe vyskytují v náhodných intervalech do tří sekund. Z této sekvence jsou sledovány pouze položky, které se vyskytují bez položky následující po dobu dvou sekund.
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));
}
}
}
}
Následující výstup byl vygenerován z ukázkového kódu.
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