C# implements simple code to bridge with existing .NET events

This article mainly introduces the relevant information of C# to implement simple instances of bridging with existing .NET events. Friends in need can refer to the following

C# Implementing a simple example of bridging with existing .NET events

Rx provides factory methods to bridge with existing asynchronous sources in .NET so that you can use them provided by any type of data stream Rich combination, filtering and resource management functions. This topic examines the FromEventPatternoperator, which allows .NET events to be "imported" into Rx as an observable sequence. Each time the event is raised, the OnNext message will be delivered to the observable sequence. You can then process the event data like any other observable sequence.

Rx is not intended to replace existing asynchronous programmingmodels, such as .NET events, async patterns, or task parallel libraries. However, when you try to write events, Rx's factory methods will provide you with conveniences you won't find in your current programming model. This is especially true for resource maintenance (e.g., when to unsubscribe) and filtering (e.g., choosing what type of data to receive). In this topic and the ones that follow, you can learn how these Rx features can help you with asynchronous programming.

Convert .NET events into Rx observable sequences

The following example creates a simple .NETevent handler program for mouse movement events, And print the mouse position in a Windows Form's label.

using System.Linq;
using System.Windows.Forms;
using System.Reactive;
using System.Reactive.Linq;
using System;
using WinForm;
using System.Reactive.Disposables;

class Program {

  static void Main() 
  {
     var lbl = new Label(); 
     var frm = new Form { Controls = { lbl } }; 
     frm.MouseMove += (sender, args) =>
     {
       lbl.Text = args.Location.ToString();
     };
     Application.Run(frm);
  }; 
}

To import events into Rx, you can use the FromEventPattern operator and provide the EventArgsobject that will be raised by the event you want to bridge. The FromEventPattern operator is used to receive events from the sender of an object and some EventArgs, and uses reflection to find these add/remove methods for you. It then converts the given event into an observable sequence with type EventPattern, which captures the sender and event parameters.

For proxies with one parameter (non-standard events), you can use the FromEvent operator, which requires a pair of functions## for attaching and detaching handlers #.

In the following example, we convert the Windows Forms mouse movement event stream into an observable sequence. Subscribers will receive an OnNext notification every time the mouse move event is triggered. We can then check the EventArgs value of such a notification and get the position of the mouse movement.

using System.Linq;
using System.Windows.Forms;
using System.Reactive;
using System.Reactive.Linq;
using System;
using WinForm;
using System.Reactive.Disposables;

class Program {

  static void Main() 
  {
     var lbl = new Label(); 
     var frm = new Form { Controls = { lbl } }; 
     IObservable<EventPattern<MouseEventArgs>> move = Observable.FromEventPattern<MouseEventArgs>(frm, "MouseMove");
     move.Subscribe(evt => { 
               lbl.Text = evt.EventArgs.Location.ToString(); 
            }) ;
     Application.Run(frm);
  }; 
}

Note that in this example, move becomes an observable sequence that we can manipulate further. The

Querying Observable Sequences using LINQ Operators topic will show you how to project this sequence into a collection of point types and filter its contents so that your application only receives values ​​that meet specific conditions.

The cleanup of the event handler is responsible for the IDisposable object returned by the Subscribe method. Calling Dispose (done by reaching the end of the use-block in this example) will release all resources being used by the sequence including the underlying event handler. This essentially unsubscribes from the event on your behalf.

The above is the detailed content of C# implements simple code to bridge with existing .NET events. For more information, please follow other related articles on the PHP Chinese website!