Observable.GroupByUntil<TSource, TKey, TElement, TDuration> Method (IObservable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)
Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et sélectionne les éléments résultants à l’aide d’une fonction spécifiée.
Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- TSource
Source de type.
- TKey
Clé de type.
- TElement
Élément type.
- TDuration
Durée du type.
Paramètres
- source
Type : System.IObservable<TSource>
Séquence observable dont les éléments doivent être groupé.
- keySelector
Type : System.Func<TSource, TKey>
Fonction permettant d'extraire la clé de chaque élément.
- elementSelector
Type : System.Func<TSource, TElement>
Fonction permettant de mapper chaque élément source à un élément dans un groupe observable.
- durationSelector
Type : System.Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>
Fonction pour signaler l’expiration d’un groupe.
Valeur de retour
Type : System.IObservable<IGroupedObservable<TKey, TElement>>
Séquence de groupes observables, chacun correspondant à une valeur de clé unique, contenant tous les éléments qui partagent cette même valeur de clé.
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 GroupByUntil sépare une séquence observable en séquences groupées observables dont l’intervalle de temps d’expiration est défini par la fonction durationSelector.
Exemples
Cet exemple simple illustre l’utilisation de l’opérateur GroupByUntil pour regrouper une séquence continue d’entiers aléatoires en groupes qui expirent après dix secondes. Appuyez sur ENTRÉE pour quitter l’exemple de code.
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();
}
}
}
La sortie suivante a été générée avec l’exemple de code.
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