Rx - 可以/应该用Observables替换.NET事件吗？ [英] Rx - can/should I replace .NET events with Observables?

问题描述

鉴于反向扩展（Rx）框架提供的可组合事件的好处，我想知道我的类是否应该停止推送.NET事件，而不是暴露Rx可观察的。

Given the benefits of composable events as offered by the Reactive Extensions (Rx) framework, I'm wondering whether my classes should stop pushing .NET events, and instead expose Rx observables.

例如，使用标准进行以下类。 NET事件：

For instance, take the following class using standard .NET events:

public class Foo
{
   private int progress;
   public event EventHandler ProgressChanged;

   public int Progress
   {
      get { return this.progress; }
      set
      {
         if (this.progress != value)
         {
            this.progress = value;

            // Raise the event while checking for no subscribers and preventing unsubscription race condition.
            var progressChanged = this.ProgressChanged;
            if (progressChanged != null)
            {
                progressChanged(this, new EventArgs());
            }
         }
      }
   }
}

很多单调的管道。

此类可以替代使用某种观察方式来替换此功能：

This class could instead use some sort of observable to replace this functionality:

public class Foo
{
   public Foo()
   {
       this.Progress = some new observable;
   }

   public IObservable<int> Progress { get; private set; }
}

更少的管道。意图不再被管道细节遮蔽。这显然是有益的。

Far less plumbing. Intention is no longer obscured by plumbing details. This seems beneficial.

我对你的问题，你好StackOverflow的人是：

1. 使用IObservable< T>替换标准.NET事件会很好/值得值？


2. 如果我使用观察器，我将在这里使用什么？显然我需要推值（例如Progress.UpdateValue（...）或某事）。

推荐答案

我建议您管理自己的用户列表时，内置的主题可以为您做这件事。它也消除了携带您自己的可变副本T的需要。

I don't recommend managing your own subscriber list when there are built in subjects that can do that for you. It also removes the need for carrying your own mutable copy of T.

以下是我的（无评论）版本的解决方案：

Below is my (commentless) version of your solution:

public class Observable<T> : IObservable<T>, INotifyPropertyChanged 
{ 
    private readonly BehaviorSubject<T> values; 

    private PropertyChangedEventHandler propertyChanged; 

    public Observable() : this(default(T))
    {
    } 

    public Observable(T initalValue) 
    { 
        this.values = new BehaviorSubject<T>(initalValue);

        values.DistinctUntilChanged().Subscribe(FirePropertyChanged);
    }

    public T Value 
    { 
        get { return this.values.First(); } 
        set { values.OnNext(value); } 
    }

    private void FirePropertyChanged(T value)
    {
        var handler = this.propertyChanged;

        if (handler != null)
            handler(this, new PropertyChangedEventArgs("Value"));
    }

    public override string ToString() 
    { 
        return value != null ? value.ToString() : "Observable<" + typeof(T).Name + "> with null value."; 
    } 

    public static implicit operator T(Observable<T> input) 
    { 
        return input.Value; 
    } 

    public IDisposable Subscribe(IObserver<T> observer) 
    { 
        return values.Subscribe(observer);
    } 

    event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged 
    { 
        add { this.propertyChanged += value; } 
        remove { this.propertyChanged -= value; } 
    } 
}

这篇关于Rx - 可以/应该用Observables替换.NET事件吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！