In-depth understanding of the main interfaces of C#Rx

This article mainly introduces the main interfaces of C and related information for in-depth understanding. Friends in need can refer to

C# Rx An in-depth understanding of the main interfaces

The IObservable / IObserver interfaces are available in the .NET Framework 4.0 base class library, and they are included in the caninstall in .NET 3.5 , Silverlight 3 and 4 and in the JavaScript package.

IObservable/IObserver

Rx exposes asynchronous and event-based data sources as push-based observable sequences, powered by the .NET Framework 4.0 The new IObservable interface abstraction in . The IObservable interface is a duplication of the familiar IEnumerable interface for pull-based, enumerable collections. It represents an observable data source, which means it can send data to anyone interested. It maintains a list of dependent IObserver implementations representing such interested listeners, and automatically notifies them of any status changes.

　An implementation of the IObservable interface can be viewed as a collection of elements of type T. Therefore, an IObservable can be viewed as a collection of integers, where integers will be pushed to subscribed observers

As mentioned in "What is Rx", pushing The other half of the model is represented by the IObserver interface, which represents an observer who has registered interest through subscriptions. The item is then delivered to the observer from the observable sequence it is subscribed to.

To receive notifications from an observable collection, you use the IObservable's Subscribe method to pass it an IObserver object. In return for this observer, the Subscribe method returns an IDisposable object as a handle to the subscription. This allows you to clean up your subscription when you're done. Calling Dispose on this object detaches the observer from the source so that notifications are no longer delivered. As you can deduce, in Rx, there is no need to explicitly unsubscribe from events as in the .NET event model.

Observers support three publishing events, which are reflected by the methods of the interface. OnNext can be called zero or more times when the observable data source has data available. For example, an observable data source for mouse movement events could emit a Point object every time the mouse moves. The other two methods are used to indicate completion or errors.

The IObservable / IObserver interfaces are listed below. ​

public interface IObservable<out T> 
{ 
  IDisposable Subscribe(IObserver<T> observer); 
} 
public interface IObserver<in T> 
{ 
  void OnCompleted();// Notifies the observer that the source has finished sending messages.
  void OnError(Exception error); // Notifies the observer about any exception or error.
  void OnNext(T value);     // Pushes the next data value from the source to the observer.
}

Rx also provides the Subscribe extension method so that you can avoid implementing the IObserver interface yourself. For each published event (OnNext, OnError, OnCompleted) of the observable sequence, you can specify the delegate that will be called, as shown in the example below. If you do not specify an action for an event, the default behavior will occur.

IObservable<int> source = Observable.Range(1, 5); //creates an observable sequence of 5 integers, starting from 1
IDisposable subscription = source.Subscribe(
              x => Console.WriteLine("OnNext: {0}", x), //prints out the value being pushed
              ex => Console.WriteLine("OnError: {0}", ex.Message),
              () => Console.WriteLine("OnCompleted"));

You can think of observable sequences (such as a sequence of mouseover events) as normal collections. Therefore, you can write LINQqueries on collections to perform filtering, grouping, composition, etc. To make observable sequences more useful, the Rx assembly provides a number of factory LINQoperators, so you don't need to implement any of these yourself. This will query the observable sequence subject using LINQ operators.

Warning:

You do not need to implement the IObservable / IObserver interface yourself. Rx provides you with internal implementations of these interfaces and exposes them through various extension methods provided by the Observable and Observer types. For more information, see the Creating and Querying Observable Sequences topic

The above is the detailed content of In-depth understanding of the main interfaces of C#Rx. For more information, please follow other related articles on the PHP Chinese website!