Observable.FromEventPattern<, méthode TEventArgs> (Object, String)

Convertit un événement .NET, conforme au modèle d’événement .NET standard, en séquence observable, à l’aide de la réflexion pour rechercher un événement instance.

Espace de noms :System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)

Syntaxe

'Declaration
Public Shared Function FromEventPattern(Of TEventArgs As EventArgs) ( _
    target As Object, _
    eventName As String _
) As IObservable(Of EventPattern(Of TEventArgs))

'Usage
Dim target As Object
Dim eventName As String
Dim returnValue As IObservable(Of EventPattern(Of TEventArgs))

returnValue = Observable.FromEventPattern(target, _
    eventName)

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(
    Object target,
    string eventName
)
where TEventArgs : EventArgs

public:
generic<typename TEventArgs>
where TEventArgs : EventArgs
static IObservable<EventPattern<TEventArgs>^>^ FromEventPattern(
    Object^ target, 
    String^ eventName
)

static member FromEventPattern : 
        target:Object * 
        eventName:string -> IObservable<EventPattern<'TEventArgs>>  when 'TEventArgs : EventArgs

JScript does not support generic types and methods.

Paramètres de type

• TEventArgs
  Type de l'événement.

Paramètres

• target
  Type : System.Object
  L’objet instance qui expose l’événement à convertir.

• eventName
  Type : System.String
  Nom de l’événement à convertir.

Valeur de retour

Type : System.IObservable<EventPattern<TEventArgs>>
La valeur de retour est une séquence observable qui contient des représentations de données des appels de l’événement .NET sous-jacent.

Notes

L’opérateur FromEventPattern convertit un événement .Net en une séquence de TEventArgs> EventPattern<. Chaque instance EventPattern contient les arguments d’événement et l’objet qui envoie l’événement. Les arguments d’événement sont fournis dans la propriété EventArgs de chaque EventPattern remis dans la séquence. L’objet qui envoie l’événement est fourni dans la propriété Sender du instance EventPattern. L’événement souhaité est spécifié en passant l’objet qui expose l’événement en tant que paramètre cible et en définissant le paramètre eventName sur le nom de l’événement. Le type TEventArgs spécifie le type d’arguments d’événement qui seront remis avec chaque événement.

Exemples

Cet exemple de code montre comment utiliser l’opérateur FromEventPattern pour écouter les événements Create, Rename et Delete sur un System.IO.FileSystemWatcher. L’exemple surveille les modifications apportées au dossier C:\Users\Public et écrit les événements dans la fenêtre de console.

using System;
using System.Reactive.Linq;
using System.Reactive;
using System.IO;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************************************************************************************//
      //*** Create a FileSystemWatcher to watch the C:\Users\Public directory using the default NotifyFilter watching for ***//
      //*** changes to any type of file.                                                                                  ***//
      //*********************************************************************************************************************//

      FileSystemWatcher fsw = new FileSystemWatcher(@"C:\Users\Public", "*.*");
      fsw.EnableRaisingEvents = true;


      //***************************************************************************************//
      //*** Use the FromEventPattern operator to setup a subscription to the Created event. ***//
      //***************************************************************************************//

      IObservable<EventPattern<FileSystemEventArgs>> fswCreated = Observable.FromEventPattern<FileSystemEventArgs>(fsw, "Created");
      fswCreated.Subscribe(pattern => Console.WriteLine("{0} was created in {1}.", pattern.EventArgs.Name, ((FileSystemWatcher)pattern.Sender).Path));


      //***************************************************************************************//
      //*** Use the FromEventPattern operator to setup a subscription to the Renamed event. ***//
      //***************************************************************************************//

      IObservable<EventPattern<RenamedEventArgs>> fswRenamed = Observable.FromEventPattern<RenamedEventArgs>(fsw, "Renamed");
      fswRenamed.Subscribe(pattern => Console.WriteLine("{0} was renamed to {1} in {2}.", pattern.EventArgs.OldName, 
                                                        pattern.EventArgs.Name, ((FileSystemWatcher)pattern.Sender).Path));


      //***************************************************************************************//
      //*** Use the FromEventPattern operator to setup a subscription to the Deleted event. ***//
      //***************************************************************************************//

      IObservable<EventPattern<FileSystemEventArgs>> fswDeleted = Observable.FromEventPattern<FileSystemEventArgs>(fsw, "Deleted");
      fswDeleted.Subscribe(pattern => Console.WriteLine("{0} was deleted in {1}.", pattern.EventArgs.Name, ((FileSystemWatcher)pattern.Sender).Path));


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

La sortie suivante illustre l’exécution de l’exemple de code pour créer un fichier texte dans le répertoire C:\Users\Public. Le fichier est renommé en ExFile.txt, puis supprimé.

Press ENTER to exit...

New Text Document.txt was created in C:\Users\Public.
New Text Document.txt was renamed to ExFile.txt in C:\Users\Public.
ExFile.txt was deleted in C:\Users\Public.

Voir aussi

Référence

Classe Observable

FromEventPattern Overload

Espace de noms System.Reactive.Linq