如何使用 Rx.Net 處理可能是突發或垃圾郵件的事件？

Question

我正在編寫代碼來處理來自設備的事件，其中所述事件可能以突發、常見情況發生，或者在錯誤情況下可能非常頻繁地發生。

我想要的行為是：

• 切勿在給定時間內多次轉發事件 window。 （1分鍾）
• 在一般情況下，不要拆分事件突發（通常是幾秒鍾），在轉發之前等待靜默期
• 在錯誤情況下，如果正在生成事件但沒有在 2 倍時間 window 內轉發，則轉發最后一個事件

我發現 Throttle 通過等待一段時間然后發送最后一個事件來按我想要的方式工作。 但是，如果事件是垃圾郵件，則 Throttle 永遠不會轉發任何事件，因為靜默期 window 會反復重置。

我發現 Sample 效果很好，除非在 window 結束時發生突發，因為我對突發中間發生的事件不感興趣。

我知道這很可能可以通過使用 Switch 或 Join 來解決，但我還沒有找到一個與我的場景足夠接近的例子來讓我點擊它。

using System;
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Reactive.Concurrency;
using System.Diagnostics;

public class Program
{
    public static event EventHandler<FakeEventArgs> DeviceChange;
    public static TimeSpan window = TimeSpan.FromSeconds(60);
    public static uint eventCounter = 0;

    public static async Task Main()
    {
        var window2x = window + window;
        //Just to give a visual sense of when things are happening
        Observable.Interval(window).Subscribe(iterator => Console.WriteLine($"Non-sliding Window {iterator}"));

        //Create observable from standard event in order to use Rx.
        var eventsAsObservables = Observable.FromEventPattern<FakeEventArgs>
            (
                handler => DeviceChange += handler,
                handler => DeviceChange -= handler
            );

        //pure throttle doesn't work in the case where events always firing faster than the time window (i.e. device with faulty connection)
        //eventsAsObservables
        //  .Throttle(window)
        //  .ObserveOn(ThreadPoolScheduler.Instance)
        //  .Subscribe(evt => { var now = DateTime.Now; Console.WriteLine($"Event: {evt.EventArgs.Message} Sent at: {evt.EventArgs.Created.TimeOfDay}  Handled at: {now.TimeOfDay} Elapsed: {(now - evt.EventArgs.Created).TotalSeconds}"); });

        //pure sample doesn't work in the case where clusters of events are happening across the time window boundary (i.e. device unplugged right at time window)
        //eventsAsObservables
        //  .Sample(window)
        //  .ObserveOn(ThreadPoolScheduler.Instance)
        //  .Subscribe(evt => { var now = DateTime.Now; Console.WriteLine($"Event: {evt.EventArgs.Message} Sent at: {evt.EventArgs.Created.TimeOfDay}  Handled at: {now.TimeOfDay} Elapsed: {(now - evt.EventArgs.Created).TotalSeconds}"); });

        var throttled = eventsAsObservables.Throttle(window);
        var sampled = eventsAsObservables.Sample(window2x);

        //plain merge will forward extra events to subscribers
        //throttled
        //  .Merge(sampled)
        //  .ObserveOn(ThreadPoolScheduler.Instance)
        //  .Subscribe(evt => { var now = DateTime.Now; Console.WriteLine($"Event: {evt.EventArgs.Message} Sent at: {evt.EventArgs.Created.TimeOfDay}  Handled at: {now.TimeOfDay} Elapsed: {(now - evt.EventArgs.Created).TotalSeconds}"); });

        //How do I alter this to get the desired behavior?
        throttled
            .Select(selector => sampled)
            .Switch()
            .ObserveOn(ThreadPoolScheduler.Instance)
            .Subscribe(evt => { var now = DateTime.Now; Console.WriteLine($"Event: {evt.EventArgs.Message} Sent at: {evt.EventArgs.Created.TimeOfDay}  Handled at: {now.TimeOfDay} Elapsed: {(now - evt.EventArgs.Created).TotalSeconds}"); });

        Console.WriteLine($"About to start raising events {DateTime.Now}");
        //RaiseEvent($"{++eventCounter}");

        //These events occur very frequently
        //They cause Throttle to never forward anything because the quiet timer gets reset
        StartSpammyEventsAsync(100);

        //These events will burst on the time boundary 
        //Causes Throttle to never forward event because the quiet timer gets reset just before it expires
        //Causes Sample to forward event from the middle of the burst instead of the end
        StartBurstyEventsAsync(window);

        Console.WriteLine("\nPress ENTER to exit...\n");
        Console.ReadLine();
    }

    static void RaiseEvent(string eventedMessage) =>
        DeviceChange?.Invoke(null, new FakeEventArgs(eventedMessage));

    static async Task StartSpammyEventsAsync(int milliSeconds)
    {
        while (true)
        {
            await Task.Delay(milliSeconds).ConfigureAwait(false);
            Debug.WriteLine($"Raising event {eventCounter}");
            RaiseEvent($"{++eventCounter}");
        }
    }

    static async Task StartBurstyEventsAsync(TimeSpan window)
    {
        while (true)
        {
            await Task.Delay(window - TimeSpan.FromSeconds(1)).ConfigureAwait(false);

            //two second burst of events
            var start = DateTime.Now;
            var limit = TimeSpan.FromSeconds(2);
            while (DateTime.Now - start < limit)
            {
                await Task.Delay(100).ConfigureAwait(false);
                Debug.WriteLine($"Raising event {eventCounter}");
                RaiseEvent($"{++eventCounter}");
            }
        }
    }

    public class FakeEventArgs : EventArgs
    {
        public readonly string Message;
        public readonly DateTime Created;

        protected FakeEventArgs() { }

        public FakeEventArgs(string message):
            base()
        {
            Created = DateTime.Now;
            Message = message;
        }
    }
} 

Answer 1

混合這兩種方法怎么樣？ 這是一個ThrottleUntil擴展方法，它使用Throttle等待“突發”結束，如果“突發”未結束（也稱為“垃圾郵件”），則Interval發出項目：

public static IObservable<T> ThrottleUntil<T>(this IObservable<T> source, TimeSpan window, IScheduler scheduler)
{
    var throttle = source.Throttle(window, scheduler);
    var until = Observable.Interval(window * 2, scheduler).Select(_ => default(T));

    return source
        .Buffer(() => Observable.Merge(throttle, until).Take(1))
        .SelectMany(buffer => buffer.Any() ? buffer.TakeLast(1) : Enumerable.Empty<T>());
}

這里有一些測試用例（大理石圖對於表達你想要發生的事情非常有用）展示了它是如何工作的：

[TestFixture]
public class BurstySpammy
{
    private static long SubscriptionOffset = ReactiveTest.Subscribed;
    private static long TestOffset = ReactiveTest.Created + ReactiveTest.Subscribed;

    private static IEnumerable<TestCaseData> TestCases
    {
        get
        {
            // Time:     0---1---2---3---4---5---6---7---8---9---0---1---2---3---4---5---6---7---8---9
            // Source:   ----1---2---------------3---4-------------------5---------------------------- 
            // Expected: --------------------2-------------------4-----------------------5------------
            yield return new TestCaseData(new int[] { 1, 2, 6, 7, 13 }, new[] { 5, 10, 16 }, false).SetName("ShouldEmitFromBurst");

            // Time:     0---1---2---3---4---5---6---7---8---9---0---1---2---3---4---5---6---7---8---9
            // Source:   ----1-------2-------3-------4-------5-------6-------------------------------- 
            // Expected: ------------------------3-----------------------6----------------------------
            yield return new TestCaseData(new int[] { 1, 3, 5, 7, 9, 11 }, new[] { 6, 12 }, true).SetName("ShouldEmitFromSpam");

            // Time:     0---1---2---3---4---5---6---7---8---9---0---1---2---3---4---5---6---7---8---9
            // Source:   ----1---2---------------3---4---5-------6-------7---8---9-------------------- 
            // Expected: --------------------2-----------------------7-----------------------9--------
            yield return new TestCaseData(new int[] { 1, 2, 6, 7, 8, 10, 12, 13, 14 }, new[] { 5, 11, 17 }, false).SetName("ShouldEmitFromMix");

            // Time:     0---1---2---3---4---5---6---7---8---9---0---1---2---3---4---5---6---7---8---9
            // Source:   ----1------------------------------------------------------------------------ 
            // Expected: ----------------1------------------------------------------------------------
            yield return new TestCaseData(new int[] { 1 }, new[] { 4 }, false).SetName("ShouldNotEmitEmpty");
        }
    }

    [TestCaseSource(nameof(TestCases))]
    public void ShouldEmitCorrectly(int[] sourceTimes, int[] expectedTimes, bool basedOnSubscriptionTime)
    {
        var scheduler = new TestScheduler();

        var source = sourceTimes
            .Select((time, index) => new Recorded<Notification<int>>(TimeSpan.FromSeconds(time).Ticks, Notification.CreateOnNext(index)))
            .ToArray();

        var expected = expectedTimes
            .Select(time => (Time: basedOnSubscriptionTime ? TimeSpan.FromSeconds(time).Ticks + SubscriptionOffset : TimeSpan.FromSeconds(time).Ticks, Value: source.Last(r => r.Time <= TimeSpan.FromSeconds(time).Ticks).Value.Value))
            .Select(tuple => new Recorded<Notification<int>>(tuple.Time, Notification.CreateOnNext(tuple.Value)))
            .ToArray();

        var xs = scheduler
            .CreateHotObservable(source)
            .ThrottleUntil(TimeSpan.FromSeconds(3), scheduler);

        var observed = scheduler.Start(() => xs, TimeSpan.FromSeconds(20).Ticks + TestOffset);

        CollectionAssert.AreEqual(expected, observed.Messages);
    }
}

希望能幫助到你。