Método Observable.GroupByUntil<TSource, TKey, TElement, TDuration> (IObservable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)
Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada e seleciona os elementos resultantes usando uma função especificada.
Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)
Sintaxe
'Declaration
<ExtensionAttribute> _
Public Shared Function GroupByUntil(Of TSource, TKey, TElement, TDuration) ( _
source As IObservable(Of TSource), _
keySelector As Func(Of TSource, TKey), _
elementSelector As Func(Of TSource, TElement), _
durationSelector As Func(Of IGroupedObservable(Of TKey, TElement), IObservable(Of TDuration)) _
) As IObservable(Of IGroupedObservable(Of TKey, TElement))
'Usage
Dim source As IObservable(Of TSource)
Dim keySelector As Func(Of TSource, TKey)
Dim elementSelector As Func(Of TSource, TElement)
Dim durationSelector As Func(Of IGroupedObservable(Of TKey, TElement), IObservable(Of TDuration))
Dim returnValue As IObservable(Of IGroupedObservable(Of TKey, TElement))
returnValue = source.GroupByUntil(keySelector, _
elementSelector, durationSelector)
public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(
this IObservable<TSource> source,
Func<TSource, TKey> keySelector,
Func<TSource, TElement> elementSelector,
Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector
)
[ExtensionAttribute]
public:
generic<typename TSource, typename TKey, typename TElement, typename TDuration>
static IObservable<IGroupedObservable<TKey, TElement>^>^ GroupByUntil(
IObservable<TSource>^ source,
Func<TSource, TKey>^ keySelector,
Func<TSource, TElement>^ elementSelector,
Func<IGroupedObservable<TKey, TElement>^, IObservable<TDuration>^>^ durationSelector
)
static member GroupByUntil :
source:IObservable<'TSource> *
keySelector:Func<'TSource, 'TKey> *
elementSelector:Func<'TSource, 'TElement> *
durationSelector:Func<IGroupedObservable<'TKey, 'TElement>, IObservable<'TDuration>> -> IObservable<IGroupedObservable<'TKey, 'TElement>>
JScript does not support generic types and methods.
Parâmetros de tipo
- TSource
A origem do tipo.
- TKey
A chave de tipo.
- Telement
O elemento type.
- TDuration
A duração do tipo.
Parâmetros
- source
Tipo: System.IObservable<TSource>
Uma sequência observável cujos elementos agrupar.
- keySelector
Tipo: System.Func<TSource, TKey>
Uma função para extrair a chave de cada elemento.
- Elementselector
Tipo: System.Func<TSource, TElement>
Uma função para mapear cada elemento de origem para um elemento em um grupo observável.
- durationSelector
Tipo: System.Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>
Uma função para sinalizar a expiração de um grupo.
Valor Retornado
Tipo: System.IObservable<IGroupedObservable<TKey, TElement>>
Uma sequência de grupos observáveis, cada um deles corresponde a um valor de chave exclusivo, contendo todos os elementos que compartilham esse mesmo valor de chave.
Observação de uso
No Visual Basic e no C#, você pode chamar esse método como um método de instância em qualquer objeto do tipo IObservable<TSource>. Quando você usar a sintaxe de método de instância para chamar esse método, omita o primeiro parâmetro. Para obter mais informações, consulte ou .
Comentários
O operador GroupByUntil separa uma sequência observável em sequências agrupadas observáveis que têm um período de expiração definido pela função durationSelector.
Exemplos
Este exemplo simples demonstra o uso do operador GroupByUntil para agrupar uma sequência contínua de inteiros aleatórios em grupos que expiram após dez segundos. Pressionar ENTER sairá do código de exemplo.
using System;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
namespace Example
{
class Program
{
static void Main()
{
//*****************************************************************************************//
//*** Generate a sequence of random integers less than 100 every seconds continuously. ***//
//*****************************************************************************************//
Random rand = new Random();
var obs = Observable.Generate(rand.Next(100), // Initial value
x => true, // The termination condition. Never terminate.
x => rand.Next(100), // Iteration step function
x => x, // Selector function
x => TimeSpan.FromMilliseconds(500), // timeSelector Delay function
Scheduler.ThreadPool); // Schedule on a .NET threadpool thread
//*************************************************************************************//
//*** Generate a groups of the random integers in the sequence that are in the 80s. ***//
//*** Each grouping has an expiration set to expire in 10 seconds. This is set by ***//
//*** the durationSelector function which returns an observable sequence of time ***//
//*** spans set to 10 seconds. ***//
//*************************************************************************************//
int groupExpirationSec = 10;
var obsEighties = obs.GroupByUntil(x => (x > 79) && (x < 90),
x => x,
x => Observable.Timer(TimeSpan.FromSeconds(groupExpirationSec)));
//*************************************************************************************//
//*** Subscribe to the grouped sequences. Each grouped sequence will expire after ***//
//*** 10 seconds by completing the sequence. Display timings with the sequence so ***//
//*** this is evident. ***//
//*************************************************************************************//
obsEighties.Subscribe(groupedObs =>
{
if (groupedObs.Key == true) // True for eighties group
{
Console.WriteLine("\nNew eighties group\nThis group should expire at {0}\n",
(DateTime.Now + TimeSpan.FromSeconds(groupExpirationSec)).ToLongTimeString());
groupedObs.Subscribe(x => Console.WriteLine(x),
() => Console.WriteLine("\nGrouped sequence completed or expired. {0}\n",
DateTime.Now.ToLongTimeString()));
}
});
Console.ReadLine();
}
}
}
A saída a seguir foi gerada com o código de exemplo.
New eighties group
This group should expire at 5:10:22 PM
86
88
81
81
89
Grouped sequence completed or expired. 5:10:22 PM
New eighties group
This group should expire at 5:10:33 PM
80
88
80
88
Grouped sequence completed or expired. 5:10:33 PM
New eighties group
This group should expire at 5:10:50 PM
81
83
83
82
81
Grouped sequence completed or expired. 5:10:50 PM
New eighties group
This group should expire at 5:11:01 PM
85
86
88
Grouped sequence completed or expired. 5:11:01 PM