Question

我想要一个用于测试Rx组件的工具，它们可以像这样工作：给定指定为'v seq和键选择器函数（keySelector :: 'v -> 'k）的事件的顺序，我想创建一个Map<'k, IObservable<'k>>，其中保证组合的可观察量产生全局值由上述可枚举定义的顺序。

例如： makeObservables isEven [1;2;3;4;5;6] ......应该产生

{ true : -2-4-6|,
  false: 1-3-5| }

这是我的尝试看起来像这样：

open System
open System.Reactive.Linq
open FSharp.Control.Reactive

let subscribeAfter (o1: IObservable<'a>) (o2 : IObservable<'b>) : IObservable<'b> =
    fun (observer : IObserver<'b>) ->
        let tempObserver = { new IObserver<'a> with
                                member this.OnNext x = ()
                                member this.OnError e = observer.OnError e
                                member this.OnCompleted () = o2 |> Observable.subscribeObserver observer |> ignore
                            }
        o1.Subscribe tempObserver
    |> Observable.Create

let makeObservables (keySelector : 'a -> 'k) (xs : 'a seq) : Map<'k, IObservable<'a>> =
    let makeDependencies : ('k * IObservable<'a>) seq -> ('k * IObservable<'a>) seq = 
        let makeDep ((_, o1), (k2, o2)) = (k2, subscribeAfter o1 o2)

        Seq.pairwise
        >> Seq.map makeDep

    let makeObservable x = (keySelector x, Observable.single x)

    let firstItem = 
        Seq.head xs 
        |> makeObservable 
        |> Seq.singleton

    let dependentObservables =
        xs
        |> Seq.map makeObservable
        |> makeDependencies

    dependentObservables
    |> Seq.append firstItem
    |> Seq.groupBy fst
    |> Seq.map (fun (k, obs) -> (k, obs |> Seq.map snd |> Observable.concatSeq))
    |> Map.ofSeq

[<EntryPoint>]
let main argv = 
    let isEven x = (x % 2 = 0)

    let splits : Map<bool, IObservable<int>> =
        [1;2;3;4;5]
        |> makeObservables isEven

    use subscription =
        splits
        |> Map.toSeq
        |> Seq.map snd
        |> Observable.mergeSeq
        |> Observable.subscribe (printfn "%A")


    Console.ReadKey() |> ignore
    0 // return an integer exit code

...但结果不符合预期，观察值不在全局范围内。

显然每组中的项目都是正确的，但是当这些组合并时，它更像是一个concat然后是一个合并

预期输出为：1 2 3 4 5 ...但实际输出为1 3 5 2 4

我做错了什么？

谢谢！

Answer 1

你描述了这个想法：

{ true : -2-4-6|,
  false: 1-3-5| }

但你真的是在创造这个：

{ true : 246|,
  false: 135| }

由于观察者中的项目之间没有时间间隔，merge基本上具有恒定的竞争条件。 Rx保证给定序列的元素1将在元素2之前触发，但Merge不能保证这样的情况。

如果您希望Merge能够按原始顺序重新排序，则需要在观察者中引入时间间隔。

如何在observables之间创建依赖关系？

1 个答案: