由网友(血狱)分享简介：说我有新车能输出类型T的实例的工厂方法，我希望有一个接收可观察序列，从所有的情况下，发起了工厂方法触发的事件。 时使用合并（），因为我做了下面的正确的和最佳的方式来实现这一目标？ 我这样做的另一种方法是使用一个静态事件，使可观察序列出来的，但是我一般不喜欢使用静态的事件，很好奇任何接收专家认为将是最佳的这种情况？公共牛...

说我有新车能输出类型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;
    }
}