Question

我需要一种节流阀，其工作原理有所不同。我需要从序列中获取元素，取消订阅并在1秒钟内再次订阅。换句话说，我要在获取第一个元素后的1秒钟内忽略所有元素：

Input:  (1) -100ms- (2) -200ms- (3) -1_500ms- (4) -1_000ms- (5) -500ms- (6) ...
Output: (1) --------------------------------- (4) --------- (5) ----------- ...

如何用Rx.NET实现这个简单的事情？

Answer 1

尝试一下：

Input
    .Window(() => Observable.Timer(TimeSpan.FromSeconds(1.0)))
    .SelectMany(xs => xs.Take(1));

这是一个测试：

var query =
    Observable
        .Interval(TimeSpan.FromSeconds(0.2))
        .Window(() => Observable.Timer(TimeSpan.FromSeconds(1.0)))
        .SelectMany(xs => xs.Take(1));

这产生了：

从10跳到14仅仅是由于使用了多个线程，而不是查询中的错误。

Answer 2

@Enigmativity的答案不完全符合规范。它可能会为您想要的工作。

他的答案定义了1秒的窗口，并从每个窗口中选取第一个。但是，这不能保证您在项目之间保持一秒钟的沉默。考虑这种情况：

t     : ---------1---------2---------3
source: ------1---2------3---4----5--|
window: ---------|---------|---------|
spec  : ------1----------3-----------|
enigma: ------1---2----------4-------|

答案暗示您想要在项目1之后一秒钟什么都没有。在此之后的下一个项目是3，然后保持沉默。这是测试的编码：

var scheduler = new TestScheduler();
var source = scheduler.CreateColdObservable<int>(
    RxTest.OnNext(700.MsTicks(),  1),
    RxTest.OnNext(1100.MsTicks(), 2),
    RxTest.OnNext(1800.MsTicks(), 3),
    RxTest.OnNext(2200.MsTicks(), 4),
    RxTest.OnNext(2600.MsTicks(), 5),
    RxTest.OnCompleted<int>(3000.MsTicks())
);

var expectedResults = scheduler.CreateHotObservable<int>(
    RxTest.OnNext(700.MsTicks(),  1),
    RxTest.OnNext(1800.MsTicks(), 3),
    RxTest.OnCompleted<int>(3000.MsTicks())
);

var target = source
    .Window(() => Observable.Timer(TimeSpan.FromSeconds(1.0), scheduler))
    .SelectMany(xs => xs.Take(1));

var observer = scheduler.CreateObserver<int>();
target.Subscribe(observer);
scheduler.Start();
ReactiveAssert.AreElementsEqual(expectedResults.Messages, observer.Messages);

我认为解决此问题的最佳方法是基于Scan的带有时间戳的解决方案。您基本上将带有时间戳的最新合法消息保留在内存中，如果新消息的时间早一秒钟，则发出该消息。否则，不要：

public static IObservable<T> TrueThrottle<T>(this IObservable<T> source, TimeSpan span)
{
    return TrueThrottle<T>(source, span, Scheduler.Default);
}

public static IObservable<T> TrueThrottle<T>(this IObservable<T> source, TimeSpan span, IScheduler scheduler)
{
    return source
        .Timestamp(scheduler)
        .Scan(default(Timestamped<T>), (state, item) => state == default(Timestamped<T>) || item.Timestamp - state.Timestamp > span
            ? item
            : state
        )
        .DistinctUntilChanged()
        .Select(t => t.Value);
}

注意：测试代码使用Nuget Microsoft.Reactive.Testing和以下帮助程序类：

public static class RxTest
{
    public static long MsTicks(this int i)
    {
        return TimeSpan.FromMilliseconds(i).Ticks;
    }

    public static Recorded<Notification<T>> OnNext<T>(long msTicks, T t)
    {
        return new Recorded<Notification<T>>(msTicks, Notification.CreateOnNext(t));
    }

    public static Recorded<Notification<T>> OnCompleted<T>(long msTicks)
    {
        return new Recorded<Notification<T>>(msTicks, Notification.CreateOnCompleted<T>());
    }

    public static Recorded<Notification<T>> OnError<T>(long msTicks, Exception e)
    {
        return new Recorded<Notification<T>>(msTicks, Notification.CreateOnError<T>(e));
    }
}

Rx.NET接受元素并在一段时间后再次订阅

2 个答案: