Método Observable.FromEventPattern<TEventArgs> (Object, String)

Artigo
06/28/2011

Converte um evento .NET, em conformidade com o padrão de evento .NET padrão, em uma sequência observável, usando reflexão para localizar um evento de instância.

Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)

Sintaxe

'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.

Parâmetros de tipo

Teventargs
O tipo do evento.

Parâmetros

destino
Tipo: System.Object
A instância de objeto que expõe o evento a ser convertido.

eventName
Tipo: System.String
O nome do evento a ser convertido.

Valor Retornado

Tipo: System.IObservable<EventPattern<TEventArgs>>
O valor retornado é uma sequência observável que contém representações de dados de invocações do evento .NET subjacente.

Comentários

O operador FromEventPattern converte um evento .Net em uma sequência de EventPattern<TEventArgs>. Cada instância eventPattern contém os argumentos de evento e o objeto que envia o evento. Os argumentos de evento são fornecidos na propriedade EventArgs de cada EventPattern entregue na sequência. O objeto que envia o evento é fornecido na propriedade Sender da instância EventPattern. O evento desejado é especificado passando o objeto que expõe o evento como o parâmetro de destino e definindo o parâmetro eventName como o nome do evento. O tipo TEventArgs especifica o tipo de argumentos de evento que serão entregues com cada evento.

Exemplos

Este código de exemplo demonstra como usar o operador FromEventPattern para escutar eventos Create, Rename e Delete em um System.IO.FileSystemWatcher. O exemplo observa as alterações na pasta C:\Users\Public e grava os eventos na janela do 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();
    }
  }
}

A saída a seguir demonstra a execução do código de exemplo para criar um novo arquivo de texto no diretório C:\Users\Public. O arquivo é renomeado para ExFile.txt e, em seguida, excluído.

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.

Consulte Também

Referência

Classe Observável

Sobrecarga de FromEventPattern

System.Reactive.Linq Namespace

Compartilhar via