将来自多个来源的调用限制为单个方法答案

【问题标题】：Throttle calls from multiple sources to a single method将来自多个来源的调用限制为单个方法
【发布时间】：2018-09-21 09:16:21
【问题描述】：

我有点难过，因为我很难找到任何与我的问题相关的信息。我对 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.
    }
}

现在，这显然行不通，因为它只会限制来自单个对象的调用，这些调用的发生频率远低于 100 毫秒。我认为我需要的是某种静态 Observable，它会累积所有调用，然后在 100 毫秒后调度调用。谁能指点一下？

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

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();
    }
}

【问题讨论】：

您可以使用Queue，对该方法的调用会入队，每 100 毫秒，下一次调用会出队
见stackoverflow.com/questions/4123178/…
observable.Throttle (TimeSpan.FromMilliseconds (100)) .Subscribe (x => { MethodToCall (this); });

标签： c# reactive-programming system.reactive

【解决方案1】：

您可以在 MethodToCall 方法实现中使用 observable：

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 的内部实现细节。

【讨论】：

请在此处描述您在做什么。