Question

我有点困惑，因为我很难找到与问题相关的信息。我是System.Reactive的新手，所以也许我用错了。

我有很多对象在事件期间都调用静态方法。我想限制对该方法的调用。

public class MyObject
{
    public MyObject ()
    {    
        var observable = Observable.FromEventPattern<SizeChangedEventHandler, SizeChangedEventArgs>
            (handler => SizeChanged += handler, handler => SizeChanged -= handler);
        observable.Throttle (TimeSpan.FromMilliseconds (100));
        observable.Subscribe (x =>
        {
            MethodToCall (this);
        });    
    }

    static void MethodToCall (MyObject obj)
    {
        // Do something.
    }
}

现在，这显然不起作用，因为它仅限制了来自单个对象的调用，这种调用的发生频率通常不到100ms。我想我需要的是某种静态Observable，它会累积所有调用，然后在100ms之后调度一次调用。谁能给我一些指示？

更新：我在秒表的帮助下实现了它，这似乎也可以完成任务。不过，我仍然对反应式解决方案感到好奇。

private static Stopwatch sw = new Stopwatch();

private static void MethodToCall(MyObjectv)
{
    if (sw.ElapsedMilliseconds < 100 && sw.IsRunning)
    {
        return;
    }

    // Some code here

    if (sw.IsRunning)
    {
        sw.Restart();
    }
    else
    {
        sw.Start();
    }
}

Answer 1

您可以在MethodToCall方法实现中使用可观察对象：

private static Subject<MyObject> subject = new Subject<MyObject>();
private static IDisposable subscription = subject
    .Throttle (TimeSpan.FromMilliseconds (100))
    .Subscribe(v =>
        {
            // Some code here
        });

private static void MethodToCall(MyObject v)
{
    subject.OnNext(v);
}

然后，节流成为MethodToCall的内部实现细节。

从多个来源进行油门调用到单个方法

1 个答案: