Observable.FromEvent<TDelegate, TEventArgs-Methode> (Func<Action<TEventArgs>, TDelegate>, Action<TDelegate>, Action<TDelegate>)
Konvertiert ein .NET-Ereignis in eine beobachtbare Sequenz.
Namespace:System.Reactive.Linq
Versammlung: System.Reaktiv (in System.Reactive.dll)
Syntax
'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.
Typparameter
- Tdelegate
Der Typ des Delegaten.
- TEventArgs
Art des Ereignisses.
Parameter
- Umwandlung
Typ: System.Func<Action<TEventArgs>, TDelegate>
Eine Funktion, die verwendet wird, um den angegebenen Ereignishandler in einen Delegat zu konvertieren, der mit dem zugrunde liegenden .NET-Ereignis kompatibel ist. Der resultierende Delegat wird in Aufrufen der Aktionsparameter addHandler und removeHandler verwendet.
- Addhandler
Typ: System.Action<TDelegate>
Aktion, die den angegebenen Ereignishandler an das zugrunde liegende .NET-Ereignis anfügt.
- Removehandler
Typ: System.Action<TDelegate>
Aktion, die den angegebenen Ereignishandler vom zugrunde liegenden .NET-Ereignis trennt.
Rückgabewert
Typ: System.IObservable<TEventArgs>
Beobachtbare Sequenz, die Datendarstellungen von Aufrufen des zugrunde liegenden .NET-Ereignisses enthält.
Bemerkungen
Der FromEvent-Operator erstellt eine beobachtbare Sequenz der Ereignisargumente, die mit den zugrunde liegenden Ereignissen bereitgestellt werden, wenn sie ausgelöst werden. Der FromEvent-Operator funktioniert nur mit Delegaten des Typs Action<T>. Daher muss eine Konvertierungsfunktion verwendet werden, um einen Ereignishandler zu erstellen, der mit dem zugrunde liegenden .NET-Ereignis kompatibel ist. Der Beispielcode in diesem Thema veranschaulicht diese Konvertierung für die Delegaten System.IO.FileSystemEventHandler und System.IO.RenamedEventHandler.
Beispiele
Dieser Beispielcode veranschaulicht die Verwendung des FromEvent-Operators zum Lauschen auf Create-, Rename- und Delete-Ereignisse auf einem System.IO.FileSystemWatcher. Das Beispiel überwacht diese Ereignisse im Ordner C:\Users\Public. Der FromEvent-Operator unterstützt nur Delegaten vom Typ Action<T>. In diesem Beispiel wird der Konvertierungsparameter verwendet, um einen Lambdaausdruck zu definieren, um den System<T-Delegaten> in die Delegaten System.IO.FileSystemEventHandler und System.IO.RenamedEventHandler zu konvertieren. Die Ereignisse werden mithilfe eines Abonnements für jede der beobachtbaren Sequenzen beobachtet. Jedes der Ereignisse wird in das Konsolenfenster geschrieben.
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();
}
}
}
Die folgende Ausgabe wurde mit dem Beispielcode generiert.
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.