正确的方法合并观察序列从多个实例触发的事件 [英] Correct way to merge observable sequences for events fired from multiple instances

问题描述

说我有新车能输出类型T的实例的工厂方法，我希望有一个接收可观察序列，从所有的情况下，发起了工厂方法触发的事件。

时使用合并（），因为我做了下面的正确的和最佳的方式来实现这一目标？

我这样做的另一种方法是使用一个静态事件，使可观察序列出来的，但是我一般不喜欢使用静态的事件，很好奇任何接收专家认为将是最佳的这种情况？

 公共牛逼MakeFoo＆LT; T＆GT;（）其中T：美孚，新的（）
{
    this.instanceOfObservable.Merge（新T（））;
    回归自我;
}


公共类ObservableSequence：的IObservable＆LT; EventArgs的＆gt;中了IDisposable
{
    私人的IObservable＆LT; EventArgs的＆GT;流;

    公共ObservableSequence（）
    {
    }

    //此方法是所谓的工厂方法对于T的每个新实例
    公共无效合并（美孚实例）
    {
        如果（this.stream == NULL）
        {
            this.stream =初始化（实例）;
        }
        其他
        {
            的IObservable＆LT; EventArgs的＆GT;接下来=初始化（实例）;
            this.stream.Merge（下）;
        }
    }

    私人的IObservable＆LT; EventArgs的＆GT;初始化（富实例）
    {
            返回Observable.FromEvent
                ＆LT;事件处理程序＆LT; EventArgs的＆gt;中的EventArgs＆GT;（处理器=＆GT;
                          {
                              事件处理程序＆LT; EventArgs的＆GT; EH =（发件人，E）=＆GT; {
                                  处理器（E）;
                              };
                              返回诶;
                          }，
                          诶=＆GT; instance.SomeEvent + =诶，
                          诶=＆GT; instance.SomeEvent  -  = EH）
                             。重复（）
                             .Retry（）
                             。发布（）
                             .RefCount（）;
    }

    公共无效的Dispose（）
    {

    }

    公共IDisposable的订阅（IObserver＆LT; EventArgs的＆GT;观察员）
    {
        返回stream.Subscribe（观察员）;
    }
}
 

解决方案

滥用合并一样，是的没有的效率非常高。最简单的方法是通过一个主题，也就是你控制手的的IObservable。

 公共静态类MyAwesomeFooFactory
{
    只读静态受试对象; SomeEventArgs＆GT; someEvents =新的受试对象; SomeEventArgs＆GT;（）;

    公共静态的IObservable＆LT; SomeEventArgs＆GT; NotificationsFromAllTheEvents {{返回someEvent; }}

    公共静态美孚MakeANewFoo（）
    {
        VAR RET =新的Foo（）;
        ret.SomeEvent.Subscribe（someEvents）; //注意：我们从来没有退订，* EVAR *

        返回RET;
    }
}
 

Say I have a factory method that churns out instances of type T, and I want an Rx observable sequence for events fired from all my instances originating out of the factory method.

Is using Merge() as I have done below the correct and optimal way to achieve this?

The other way I did this was to use a static event and make the observable sequence out of that, however I generally don't like using static events and am curious what any Rx experts think would be optimal in this situation?

public T MakeFoo<T>() where T: Foo, new()
{
    this.instanceOfObservable.Merge(new T());
    return self;
}


public class ObservableSequence : IObservable<EventArgs>, IDisposable
{
    private IObservable<EventArgs> stream;

    public ObservableSequence()
    {
    }

    // this method is called in the factory method for each new instance of T
    public void Merge(Foo instance)
    {
        if (this.stream == null)
        {
            this.stream = Init(instance); 
        }
        else
        {
            IObservable<EventArgs> next = Init(instance);
            this.stream.Merge(next); 
        }
    }

    private IObservable<EventArgs> Init(Foo instance)
    {
            return Observable.FromEvent
                <EventHandler<EventArgs>, EventArgs>(handler =>
                          {
                              EventHandler<EventArgs> eh = (sender, e) => {
                                  handler(e);
                              };
                              return eh;
                          },
                          eh => instance.SomeEvent += eh ,
                          eh => instance.SomeEvent -= eh )
                             .Repeat()
                             .Retry()
                             .Publish()
                             .RefCount();
    }

    public void Dispose()
    {

    }

    public IDisposable Subscribe(IObserver<EventArgs> observer)
    {
        return stream.Subscribe(observer);
    }
}

解决方案

Abusing Merge like that is not very efficient. The most straightforward way is via a Subject, which is an IObservable you control by hand.

public static class MyAwesomeFooFactory
{
    readonly static Subject<SomeEventArgs> someEvents = new Subject<SomeEventArgs>();

    public static IObservable<SomeEventArgs> NotificationsFromAllTheEvents { get { return someEvent; }}

    public static Foo MakeANewFoo()
    {
        var ret = new Foo();
        ret.SomeEvent.Subscribe(someEvents); // NB: We never unsubscribe, *evar*

        return ret;
    }
}

这篇关于正确的方法合并观察序列从多个实例触发的事件的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！