Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Converte un evento .NET in una sequenza osservabile.
Spazio dei nomi:System.Reattivo.Linq
Assemblea: System.Reattivo (in System.Reactive.dll)
Sintassi
'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.
Parametri di tipo
- TDelegate
Tipo di delegato.
- TEventArgs
Tipo di evento.
Parametri
- conversione
Tipo: System.Func<Action<TEventArgs>, TDelegate>
Funzione usata per convertire il gestore eventi specificato in un delegato compatibile con l'evento .NET sottostante. Il delegato risultante viene usato nelle chiamate ai parametri dell'azione addHandler e removeHandler.
- Addhandler
Tipo: System.Action<TDelegate>
Azione che collega il gestore eventi specificato all'evento .NET sottostante.
- Removehandler
Tipo: System.Action<TDelegate>
Azione che scollega il gestore eventi specificato dall'evento .NET sottostante.
Valore restituito
Tipo: System.IObservable<TEventArgs>
Sequenza osservabile che contiene rappresentazioni di dati delle chiamate dell'evento .NET sottostante.
Commenti
L'operatore FromEvent crea una sequenza osservabile degli argomenti dell'evento forniti con gli eventi sottostanti quando vengono attivati. L'operatore FromEvent funziona solo con delegati del tipo Action<T>. È quindi necessario usare una funzione di conversione per creare un gestore eventi compatibile con l'evento .NET sottostante. Il codice di esempio in questo argomento illustra questa conversione per i delegati System.IO.FileSystemEventHandler e System.IO.RenamedEventHandler.
Esempio
Questo codice di esempio illustra l'uso dell'operatore FromEvent per ascoltare gli eventi Create, Rename e Delete in un System.IO.FileSystemWatcher. L'esempio controlla questi eventi nella cartella C:\Users\Public. L'operatore FromEvent supporta solo delegati del tipo Action<T>. In questo esempio viene usato il parametro di conversione per definire un'espressione lambda per convertire il delegato T di sistema<> in System.IO.FileSystemEventHandler e i delegati System.IO.RenamedEventHandler. Gli eventi vengono osservati usando una sottoscrizione a ognuna delle sequenze osservabili. Ognuno degli eventi viene scritto nella finestra della 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();
}
}
}
L'output seguente è stato generato con il codice di esempio.
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.