System.Reactive.Joins指南

Question

我正在寻找System.Reactive.Joins的介绍/一些文档，其中包括Pattern，Plan，QueryablePattern和QueryablePlan类。谷歌没有发现任何东西（“System.Reactive.Joins”），MSDN什么都没有，没有样本here，this question的优秀资源不包括这个命名空间。

有没有人有指示？

Answer 1

找到了一个很好的SO问题，显示了用法，但对我来说，Plan和Pattern的总体目的是创建一个可观察的组合单元而不是组合的可观察对象。语义，我知道，但对我来说，使用这种语法然后使用各种其他“加入”方法似乎更容易一些。它允许您将连接与投影完全分开，因此您可以存储中间计划并随时将其与其他可观察对象组合。

例如：

// Suppose we have observables o1, o2, ..., o9. All IObservable<int>.
var o1and2 = o1.And(o2); // Store this bad boy for later use. Pattern<int, int>
var o5and6and9 = o5.And(o6).And(o9).Then((t1,t2,t3) => t1+t2+t3); // Plan<int>
var o3and7 = o3.And(o7).Then((t1,t2) => string.Format("Result: {0}", t1+t2)); // Plan<string>
var o12ando8and6 = o1and2.And(o8).And(o6).Then((t1,t2,t3,t4) => new Tuple((decimal)t1, t2, t3.ToString(), t4)); // Plan<Tuple<decimal, int, string, int>>
// When similar results together. This will fire when any of the Patterns give a result.
var firstObserve = Observable.When(o1and2.Then((t1,t2) => t1+t2), o5and6and9); // IObservable<int>
var secondObserve = Observable.When(o3and7); // IObservable<string>
var thirdObserve = Observable.When(o12ando8and6); // IObservable<Tuple<decimal, int, string,int>>

SO文章： Reactive Extensions for .NET (Rx): Take action once all events are completed

另外，找到了一个实际上有助于理解如何使用它的RX文档：

http://www.clipcode.net/mentoring/RxReferenceLibrary.pdf

Answer 2

这是我发现的唯一一件事：Join Patterns in Rx。我还想看到有关这些主题的其他资源。

Answer 3

  

Reactive Extensions for .NET (Rx) ^{blogs.msdn.com}

     

...然后等待使用连接模式返回三个结果中的前两个。

  

How to join multiple IObservable sequences? ^{stackoverflow.com}

     

如何在v.2838中使用新的Join运算符...

  

Introduction to the Reactive Extensions for JavaScript – New Release and Joins ^{weblogs.asp.net}

     

... JavaScript的Reactive Extensions，其中包括我最近一直在讨论的许多变化，包括第三方库集成，我在之前的帖子中介绍的聚合，以及今天发布的主题的联接。

  

System.Reactive.Joins Namespace ^{msdn.microsoft.com}

     

Microsoft对System.Reactive.Joins命名空间的定义。

Answer 4

除了我提到的例子here（现在更新为使用Observable.When而不是Observable.Join），我的一般概念似乎是你在你想要时使用When和join模式组成事件本身，而不是事件的内容。所以，当我想做一些与被观察数据相关的事情时，我会使用其他查询运算符，比如SelectMany。当我想做一些纯粹响应哪些事件以及哪些事件模式按特定顺序触发时，我会使用连接模式。现在，这并不是说你不能组合其他的查询运算符，比如，Where和Select来过滤并从IObservable中输出一些值，这些值稍后将用于连接模式，但我认为这是一个很好的通用方法看看它。

我确实尝试过一些例子，但我还没有真正想出更好的东西......只是更复杂的相同概念。您希望对相关事件模式进行分组，这些模式可能具有在事件级别而非IObservable内容中有意义的复杂关系。

Answer 5

使用Reflector（或类似工具），这不是一个坏主意 目前，浏览源代码对于Rx来说是非常宝贵的工具。您可以看到它实现了什么，如何 - 并与其他标准Rx模式进行比较 此外，也许你可以发布一个问题，你想要解决的问题 - 然后从那里开始（其他人可能有更多想法）。
编辑： Rx没有源代码。然而，即使Rx人员建议使用Reflector或类似工具拆卸它来分析库。例如。你可以免费使用ILSpy，下载Rx-Providers Nuget，或者你有我想的，将System.Reactive.Providers.dll和System.Reactive.dll加载到其中并享受:)。这不是完美的，也不是官方的，也不是至少容易编译 - 但是你可以很好地了解事情是如何运作的，它对我有很大的帮助， 非常宝贵！ < / p>

Answer 6

我也找不到很多。但是我自己的尝试取得了一些成功。

该cotacha是：delayObservable的类型参数没有任何意义。它们仅声明为具有返回值don't care。似乎（*我不知道）喜欢 IObservable<>的唯一目的是监听OnCompleted事件。

因此，我在实验中使用了这个Observable：

IObservable<long> timingobs = Observable.Interval(TimeSpan.FromMilliseconds(100)).Take(1);

如果您找到可快速结束的Observable的简单解决方案，请告诉我。

如果您使用不同量（例如600）的毫秒，则结果会有所不同。

代码：

            var apples = Observable.Create<Apple>(o => Task.Run(() =>
            {
                o.OnNext(Apple.boskop);
                Thread.Sleep(500);
                o.OnNext(Apple.boskop);
                o.OnNext(Apple.granny);
                Thread.Sleep(500);
                o.OnNext(Apple.pink);
                o.OnNext(Apple.pink);
                Thread.Sleep(500);
                o.OnNext(Apple.granny);
                o.OnCompleted();
                return Disposable.Empty;
            }));

            var pears = Observable.Create<Pear>(o => Task.Run(()=>
            {
                o.OnNext(Pear.AA);
                Thread.Sleep(300);
                o.OnNext(Pear.BB);
                o.OnNext(Pear.CC);
                Thread.Sleep(300);
                o.OnNext(Pear.BB);
                Thread.Sleep(300);
                o.OnNext(Pear.DD);
                o.OnCompleted();
                return Disposable.Empty;
            }));



            IObservable<long> timingobs = Observable.Interval(TimeSpan.FromMilliseconds(100)).Take(1);
            pears.Join(apples, a => timingobs, p => timingobs, (pear, apple) => $"{apple} + {pear}")
                .Subscribe(Console.WriteLine);

            Console.ReadKey();

结果（100毫秒）：

boskop + AA
pink + DD
pink + DD

结果（600毫秒）：

boskop + AA
boskop + BB
boskop + CC
boskop + AA
boskop + BB
boskop + CC
granny + AA
granny + BB
granny + CC
boskop + BB
boskop + BB
granny + BB
boskop + DD
granny + DD
pink + BB
pink + DD
pink + BB
pink + DD
granny + DD