Observable.Buffer<TSource> – metoda (IObservable<TSource>, TimeSpan, TimeSpan, IScheduler)
Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování.
Obor názvů:System.Reactive.Linq
Sestavení: System.Reactive (v System.Reactive.dll)
Syntax
'Declaration
<ExtensionAttribute> _
Public Shared Function Buffer(Of TSource) ( _
source As IObservable(Of TSource), _
timeSpan As TimeSpan, _
timeShift As TimeSpan, _
scheduler As IScheduler _
) As IObservable(Of IList(Of TSource))
'Usage
Dim source As IObservable(Of TSource)
Dim timeSpan As TimeSpan
Dim timeShift As TimeSpan
Dim scheduler As IScheduler
Dim returnValue As IObservable(Of IList(Of TSource))
returnValue = source.Buffer(timeSpan, _
timeShift, scheduler)
public static IObservable<IList<TSource>> Buffer<TSource>(
this IObservable<TSource> source,
TimeSpan timeSpan,
TimeSpan timeShift,
IScheduler scheduler
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<IList<TSource>^>^ Buffer(
IObservable<TSource>^ source,
TimeSpan timeSpan,
TimeSpan timeShift,
IScheduler^ scheduler
)
static member Buffer :
source:IObservable<'TSource> *
timeSpan:TimeSpan *
timeShift:TimeSpan *
scheduler:IScheduler -> IObservable<IList<'TSource>>
JScript does not support generic types and methods.
Parametry typu
- Tsource
Typ zdroje.
Parametry
- source
Typ: System.IObservable<TSource>
Zdrojová sekvence pro vytváření vyrovnávacích pamětí.
- Timespan
Typ: System.TimeSpan
Délka každé vyrovnávací paměti.
- Timeshift
Typ: System.TimeSpan
Interval mezi vytvořením po sobě jdoucích vyrovnávacích pamětí.
- scheduler
Typ: System.Reactive.Concurrency.IScheduler
Plánovač, na který se mají časovače ukládat do vyrovnávací paměti.
Návratová hodnota
Typ: System.IObservable<IList<TSource>>
Pozorovaná sekvence ve vyrovnávací paměti.
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
Tento operátor vytvoří vyrovnávací paměť, která bude obsahovat všechny položky, které se vyskytují během doby trvání parametru timeSpan. To umožňuje aplikaci ukládat položky do vyrovnávací paměti, které se mají doručovat v dávkách. Parametr timeShift označuje, jak často by se měly spouštět obslužné rutiny předplatného pro položky ve vyrovnávací paměti, což vede k odeslání položek odběratelům. Parametr scheduleru řídí, ve kterém vlákně se budou časovače pro vyrovnávací paměť vytvářet.
Příklady
Ukázkový kód vygeneruje nekonečnou sekvenci e-mailů z IEnumerable, která náhodně vygeneruje e-mail do tří sekund. E-maily mají časové razítko pomocí operátoru IObservable.TimeStamp. Pak se ukládají do vyrovnávací paměti, která uchovává všechny e-maily, které se vyskytují během deseti sekund. Vytvoří se odběr sekvence ve vyrovnávací paměti. Nakonec se každá skupina e-mailů zapíše do okna konzoly spolu s odpovídajícím časovým razítkem vygenerovaným pro e-mail.
using System;
using System.Collections.Generic;
using System.Threading;
using System.Reactive.Linq;
using System.Reactive;
namespace Example
{
class Program
{
static void Main()
{
//************************************************************************************************************************//
//*** By generating an observable sequence from the enumerator, we can use Rx to push the emails to an email buffer ***//
//*** and have the buffer dumped at an interval we choose. This simulates how often email is checked for new messages. ***//
//************************************************************************************************************************//
IObservable<string> myInbox = EndlessBarrageOfEmails().ToObservable();
//************************************************************************************************************************//
//*** We can use the Timestamp operator to additionally timestamp each email in the sequence when it is received. ***//
//************************************************************************************************************************//
IObservable<Timestamped<string>> myInboxTimestamped = myInbox.Timestamp();
//******************************************************************************************************************************//
//*** The timer controls the frequency of emails delivered from the email buffer. This timer will be on another thread since ***//
//*** the main thread will be blocked waiting on a key press. ***//
//******************************************************************************************************************************//
System.Reactive.Concurrency.IScheduler scheduleOnNewThread = System.Reactive.Concurrency.Scheduler.NewThread;
//***************************************************************************************************************************//
//*** Create a buffer with Rx that will hold all emails received within 10 secs and execute subscription handlers for the ***//
//*** buffer every 10 secs. ***//
//*** Schedule the timers associated with emptying the buffer to be created on the new thread. ***//
//***************************************************************************************************************************//
IObservable<IList<Timestamped<string>>> newMail = myInboxTimestamped.Buffer(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10),
scheduleOnNewThread);
//******************************************************//
//*** Activate the subscription on a separate thread ***//
//******************************************************//
IDisposable handle = newMail.SubscribeOn(scheduleOnNewThread).Subscribe(emailList =>
{
Console.WriteLine("\nYou've got mail! {0} messages.\n", emailList.Count);
foreach (Timestamped<string> email in emailList)
{
Console.WriteLine("Message : {0}\nTimestamp : {1}\n", email.Value, email.Timestamp.ToString());
}
});
Console.ReadLine();
handle.Dispose();
}
//*********************************************************************************************//
//*** ***//
//*** 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));
}
}
}
}
Tady je příklad výstupu z ukázkového kódu.
You've got mail! 6 messages.
Message : Email Msg from John
Timestamp : 5/16/2011 3:45:09 PM -04:00
Message : Email Msg from Wes
Timestamp : 5/16/2011 3:45:12 PM -04:00
Message : Email Msg from Marcy
Timestamp : 5/16/2011 3:45:13 PM -04:00
Message : Email Msg from Bill
Timestamp : 5/16/2011 3:45:13 PM -04:00
Message : Email Msg from Marcy
Timestamp : 5/16/2011 3:45:13 PM -04:00
Message : Email Msg from Marcy
Timestamp : 5/16/2011 3:45:15 PM -04:00
You've got mail! 7 messages.
Message : Email Msg from Marcy
Timestamp : 5/16/2011 3:45:17 PM -04:00
Message : Email Msg from Bill
Timestamp : 5/16/2011 3:45:18 PM -04:00
Message : Email Msg from Wes
Timestamp : 5/16/2011 3:45:19 PM -04:00
Message : Email Msg from Bill
Timestamp : 5/16/2011 3:45:21 PM -04:00
Message : Email Msg from Bill
Timestamp : 5/16/2011 3:45:24 PM -04:00
Message : Email Msg from Bill
Timestamp : 5/16/2011 3:45:26 PM -04:00
Message : Email Msg from Marcy
Timestamp : 5/16/2011 3:45:26 PM -04:00