Observable.FromEvent<TDelegate, méthode TEventArgs> (Action func<<TEventArgs>, TDelegate>, Action<TDelegate>, Action<TDelegate>)
Convertit un événement .NET en séquence observable.
Espace de noms :System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'Declaration
Public Shared Function FromEvent(Of TDelegate, TEventArgs) ( _
conversion As Func(Of Action(Of TEventArgs), TDelegate), _
addHandler As Action(Of TDelegate), _
removeHandler As Action(Of TDelegate) _
) As IObservable(Of TEventArgs)
'Usage
Dim conversion As Func(Of Action(Of TEventArgs), TDelegate)
Dim addHandler As Action(Of TDelegate)
Dim removeHandler As Action(Of TDelegate)
Dim returnValue As IObservable(Of TEventArgs)
returnValue = Observable.FromEvent(conversion, _
addHandler, removeHandler)
public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(
Func<Action<TEventArgs>, TDelegate> conversion,
Action<TDelegate> addHandler,
Action<TDelegate> removeHandler
)
public:
generic<typename TDelegate, typename TEventArgs>
static IObservable<TEventArgs>^ FromEvent(
Func<Action<TEventArgs>^, TDelegate>^ conversion,
Action<TDelegate>^ addHandler,
Action<TDelegate>^ removeHandler
)
static member FromEvent :
conversion:Func<Action<'TEventArgs>, 'TDelegate> *
addHandler:Action<'TDelegate> *
removeHandler:Action<'TDelegate> -> IObservable<'TEventArgs>
JScript does not support generic types and methods.
Paramètres de type
- TDelegate
Type de délégué.
- TEventArgs
Type de l'événement.
Paramètres
- conversion
Type : System.Func<Action<TEventArgs>, TDelegate>
Fonction utilisée pour convertir le gestionnaire d’événements donné en délégué compatible avec l’événement .NET sous-jacent. Le délégué résultant est utilisé dans les appels aux paramètres d’action addHandler et removeHandler.
- Addhandler
Type : System.Action<TDelegate>
Action qui joint le gestionnaire d’événements donné à l’événement .NET sous-jacent.
- removeHandler
Type : System.Action<TDelegate>
Action qui détache le gestionnaire d’événements donné de l’événement .NET sous-jacent.
Valeur de retour
Type : System.IObservable<TEventArgs>
Séquence observable qui contient des représentations de données des appels de l’événement .NET sous-jacent.
Notes
L’opérateur FromEvent crée une séquence observable des arguments d’événement fournis avec les événements sous-jacents lorsqu’ils sont déclenchés. L’opérateur FromEvent fonctionne uniquement avec les délégués du type Action<T>. Par conséquent, une fonction de conversion doit être utilisée pour créer un gestionnaire d’événements compatible avec l’événement .NET sous-jacent. L’exemple de code de cette rubrique illustre cette conversion pour les délégués System.IO.FileSystemEventHandler et System.IO.RenamedEventHandler.
Exemples
Cet exemple de code montre comment utiliser l’opérateur FromEvent pour écouter les événements Create, Rename et Delete sur un System.IO.FileSystemWatcher. L’exemple surveille ces événements dans le dossier C:\Users\Public. L’opérateur FromEvent prend uniquement en charge les délégués du type Action<T>. Par conséquent, cet exemple utilise le paramètre de conversion pour définir une expression lambda afin de convertir le délégué System<T> en délégués System.IO.FileSystemEventHandler et System.IO.RenamedEventHandler. Les événements sont observés à l’aide d’un abonnement à chacune des séquences observables. Chacun des événements est écrit dans la fenêtre de console.
using System;
using System.Reactive.Linq;
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 FromEvent operator to setup a subscription to the Created event. ***//
//*** ***//
//*** The first lambda expression performs the conversion of Action<FileSystemEventArgs> ***//
//*** to FileSystemEventHandler. The FileSystemEventHandler just calls the handler ***//
//*** passing the FileSystemEventArgs. ***//
//*** ***//
//*** The other lambda expressions add and remove the FileSystemEventHandler to and from ***//
//*** the event. ***//
//******************************************************************************************//
var fswCreated = Observable.FromEvent<FileSystemEventHandler, FileSystemEventArgs>(handler =>
{
FileSystemEventHandler fsHandler = (sender, e) =>
{
handler(e);
};
return fsHandler;
},
fsHandler => fsw.Created += fsHandler,
fsHandler => fsw.Created -= fsHandler);
fswCreated.Subscribe(e => Console.WriteLine("{0} was created.", e.FullPath));
//******************************************************************************************//
//*** Use the FromEvent operator to setup a subscription to the Renamed event. ***//
//*** ***//
//*** The first lambda expression performs the conversion of Action<RenamedEventArgs> ***//
//*** to RenamedEventHandler. The RenamedEventHandler just calls the handler passing the ***//
//*** RenamedEventArgs. ***//
//*** ***//
//*** The other lambda expressions add and remove the RenamedEventHandler to and from ***//
//*** the event. ***//
//******************************************************************************************//
var fswRenamed = Observable.FromEvent<RenamedEventHandler, RenamedEventArgs>(handler =>
{
RenamedEventHandler fsHandler = (sender, e) =>
{
handler(e);
};
return fsHandler;
},
fsHandler => fsw.Renamed += fsHandler,
fsHandler => fsw.Renamed -= fsHandler);
fswRenamed.Subscribe(e => Console.WriteLine("{0} was renamed to {1}.", e.OldFullPath, e.FullPath));
//******************************************************************************************//
//*** Use the FromEvent operator to setup a subscription to the Deleted event. ***//
//*** ***//
//*** The first lambda expression performs the conversion of Action<FileSystemEventArgs> ***//
//*** to FileSystemEventHandler. The FileSystemEventHandler just calls the handler ***//
//*** passing the FileSystemEventArgs. ***//
//*** ***//
//*** The other lambda expressions add and remove the FileSystemEventHandler to and from ***//
//*** the event. ***//
//******************************************************************************************//
var fswDeleted = Observable.FromEvent<FileSystemEventHandler, FileSystemEventArgs>(handler =>
{
FileSystemEventHandler fsHandler = (sender, e) =>
{
handler(e);
};
return fsHandler;
},
fsHandler => fsw.Deleted += fsHandler,
fsHandler => fsw.Deleted -= fsHandler);
fswDeleted.Subscribe(e => Console.WriteLine("{0} was deleted.", e.FullPath));
Console.WriteLine("Press ENTER to exit...\n");
Console.ReadLine();
}
}
}
La sortie suivante a été générée avec l’exemple de code.
Press ENTER to exit...
C:\Users\Public\New Text Document.txt was created.
C:\Users\Public\New Text Document.txt was renamed to C:\Users\Public\TestFile.txt.
C:\Users\Public\TestFile.txt was deleted.