Question

我是Rx的新手，我非常喜欢它。我发现我们的代码的现有部分可以通过使用它来大大简化。我遇到了性能问题，如果那里有一位可以帮助我的大师，我将非常感激。

以前我有一个手动实现的观察者类，它接受订阅和密钥过滤器。当一个事件进入该类时，它将使用提供的密钥来查找哪些观察者需要回调。这是代码的一个非常简化的版本：

 class OldClass
 {
    private Dictionary<string, List<Action<UsefulInfo>> _callbacks = 
        new Dictionary<string, List<Action<UsefulInfo>>();

    void Subscribe(string key, Action<UsefulInfo> callback)
    {
        _callbacks[key].Add(callback);
    }

    // Some event happens that we want to notify subscribers about
    void EventHandler(object sender, SomeEventArgs e)
    {
        // Create object for callbacks
        UsefulInfo info = CreateUsefulInfo(e);

        string key = info.Key;

        // Look up callbacks for key
        _callbacks[key].ForEach(callback => callback(info));
    }
 }

我已将此更新为使用Rx，如下所示：

class NewClass
{
    private Subject<UsefulInfo> _subject = new Subject<UsefulInfo>();
    private IObservable<UsefulInfo> _observable;

    public NewClass()
    {
        _observable = _subject.ToObservable();
    }

    IDisposable Subscribe(string key, Action<UsefulInfo> callback)
    {
        return _observable.Where(x => x.Key == key).Subscribe(callback);
    }

    // Some event happens that we want to notify subscribers about
    void EventHandler(object sender, SomeEventArgs e)
    {
        UsefulInfo info = CreateUsefulInfo(e);

        _observable.OnNext(info);
    }
 }

旧代码执行O（1）字典键查找以查找回调，但新的Rx代码调用Where Func O（n）次。我有成千上万的观察员。

有没有办法可以给Rx一个Func，它返回一个键，然后它可以在内部用来将观察者存储在字典中？还有另一种方法可以提高性能吗？或者我是否以非预期的方式使用框架？

Answer 1

您可以使用Where'd序列上的Publish分享观察者，然后使用IConnectableObservable上的RefCount更智能地管理对源的订阅。

在您的场景中，我想您会将这些“已发布的”可观察量存储在字典中并根据需要添加它们。

这是一个基本的实现：

class NewClass 
{ 
    private Subject<UsefulInfo> _subject = new Subject<UsefulInfo>(); 
    private IDictionary<string, IObservable<UsefulInfo>> _keyedObservables; 

    public NewClass() 
    { 
        _keyedObservables = new Dictionary<string, IObservable<UsefulInfo>>();
    } 

    IDisposable Subscribe(string key, Action<UsefulInfo> callback) 
    { 
        // NOT threadsafe for concurrent subscriptions!
        if (!_keyedObservables.Contains(key))
        {
            var keyedAndPublished = _subject.Where(x => x.Key == key)
                .Publish()
                .RefCount();

            _keyedObservables.Add(key, keyedAndPublished);
        }

        return _keyedObservables[key].Subscribe(callback);
    } 

    // Some event happens that we want to notify subscribers about 
    void EventHandler(object sender, SomeEventArgs e) 
    { 
        UsefulInfo info = CreateUsefulInfo(e); 

        _observable.OnNext(info); 
    } 
}

如何使用1000个观察者有效地运行Observable.Where（）？

1 个答案: