Partager via


Observable.MaxBy<TSource, méthode TKey> (IObservable<TSource>, Func<TSource, TKey>)

Retourne les éléments d’une séquence observable avec la valeur de clé maximale.

Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)

Syntaxe

'Declaration
<ExtensionAttribute> _
Public Shared Function MaxBy(Of TSource, TKey) ( _
    source As IObservable(Of TSource), _
    keySelector As Func(Of TSource, TKey) _
) As IObservable(Of IList(Of TSource))
'Usage
Dim source As IObservable(Of TSource)
Dim keySelector As Func(Of TSource, TKey)
Dim returnValue As IObservable(Of IList(Of TSource))

returnValue = source.MaxBy(keySelector)
public static IObservable<IList<TSource>> MaxBy<TSource, TKey>(
    this IObservable<TSource> source,
    Func<TSource, TKey> keySelector
)
[ExtensionAttribute]
public:
generic<typename TSource, typename TKey>
static IObservable<IList<TSource>^>^ MaxBy(
    IObservable<TSource>^ source, 
    Func<TSource, TKey>^ keySelector
)
static member MaxBy : 
        source:IObservable<'TSource> * 
        keySelector:Func<'TSource, 'TKey> -> IObservable<IList<'TSource>> 
JScript does not support generic types and methods.

Paramètres de type

  • TSource
    Type de la source.
  • TKey
    Type de clé.

Paramètres

  • source
    Type : System.IObservable<TSource>
    Séquence observable pour laquelle obtenir le nombre maximal d’éléments.
  • keySelector
    Type : System.Func<TSource, TKey>
    Fonction de sélecteur de clé.

Valeur de retour

Type : System.IObservable<IList<TSource>>
Éléments d’une séquence observable avec la valeur de clé maximale.

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 MaxBy est utilisé pour obtenir les éléments de la séquence qui génèrent une valeur de clé maximale. Par exemple, si la séquence était une séquence de tous les processus en cours d’exécution sur un ordinateur, l’opérateur MaxBy peut être utilisé pour retourner les processus qui ont alloué le plus de mémoire physique . L’exemple de code de cette rubrique le montre.

Exemples

L’exemple de code suivant crée une séquence observable de tous les processus en cours d’exécution sur l’ordinateur local. Ensuite, l’opérateur MaxBy est utilisé pour retourner une séquence observable qui contient une liste des processus avec qui ont alloué le plus de mémoire physique. Les informations de processus pour les processus de la liste sont écrites dans la fenêtre de console.

using System;
using System.Reactive.Linq;
using System.Diagnostics;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************************************************************//
      //*** Generate a sequence of processes running on the local machine.                        ***//
      //*********************************************************************************************//

      var seqProcesses = System.Diagnostics.Process.GetProcesses().ToObservable();


      //*********************************************************************************************//
      //*** Use the MaxBy operator to get a list of the processes that have the highest amount    ***//
      //*** of physical memory allocated.                                                         ***//
      //*********************************************************************************************//

      var maxWorkingSet = seqProcesses.MaxBy(p => p.WorkingSet64);


      //*********************************************************************************************//
      //*** Write the process information to the console window for the processes which have      ***//
      //*** allocated the most physical memory                                                    ***//
      //*********************************************************************************************//

      maxWorkingSet.Subscribe(maxList => 
      {
        foreach (Process process in maxList)
        {
          Console.WriteLine("\nDescription   : {0}\n" + 
                            "Filename      : {1}\n" + 
                            "Working Set   : {2}", 
                            process.MainModule.FileVersionInfo.FileDescription, 
                            process.MainModule.FileName, 
                            process.WorkingSet64);
        }
      });

      Console.WriteLine("\nPress ENTER to exit...\n");
      Console.ReadLine();
    }
  }
}

La sortie suivante a été générée par l’exemple de code.

Description   : Desktop Window Manager
Filename      : C:\Windows\system32\Dwm.exe
Working Set   : 363646976

Press ENTER to exit...

Voir aussi

Référence

Observable, classe

Surcharge MaxBy

Espace de noms System.Reactive.Linq