我正在尝试重新排序在不同线程上无序的事件。
是否可以创建与这些大理石图匹配的反应式扩展查询：
s1 1 2 3 4
s2 1 3 2 4
result 1 2 3 4
和...
s1 1 2 3 4
s2 4 3 2 1
result 1234
即：仅以版本号顺序发布结果。
我最接近的是每次s1打勾时使用Join打开一个窗口，只有当s2到达且具有相同的数字时才关闭它。
像这样：
var publishedEvents = events.Publish().RefCount();
publishedEvents.Join(
publishedEvents.Scan(0, (i, o) => i + 1),
expectedVersion => publishedEvents.Any(@event => @event.Version == expectedVersion),
_ => Observable.Never<Unit>(),
(@event, expectedVersion) => new {@event,expectedVersion})
.Where(x => x.expectedVersion == x.@event.Version)
.Select(x => x.@event)
.Subscribe(Persist);
但这不适用于图表编号2.第2组将在s2编号为2后完成，因此在1之前。
有意义吗？可以用Rx完成吗？应该吗？
编辑：我想这就像是重叠的窗口，后面的窗口在所有前面的窗口关闭之前都无法关闭。并且在窗口编号与事件版本号匹配之前，前面的窗口不会关闭。
编辑2 ：
我现在有类似的东西，但它不是真正的反应性，功能性，线程安全的LINQ启示，我希望（请忽略我的事件现在是JObjects）：
var orderedEvents = Observable.Create<JObject>(observer =>
{
var nextVersionExpected = 1;
var previousEvents = new List<JObject>();
return events
.ObserveOn(Scheduler.CurrentThread)
.Subscribe(@event =>
{
previousEvents.Add(@event);
var version = (long) @event["Version"];
if (version != nextVersionExpected) return;
foreach (var previousEvent in previousEvents.OrderBy(x => (long) x["Version"]).ToList())
{
if ((long) previousEvent["Version"] != nextVersionExpected)
break;
observer.OnNext(previousEvent);
previousEvents.Remove(previousEvent);
nextVersionExpected++;
}
});
});
答案 0 :(得分：11)
这个问题的关键是排序。无论如何你看它，需要某种形式的缓冲。虽然毫无疑问，一些精心设计的运算符组合可能会实现这一点，但我认为这是一个很好的例子，其中Observable.Create是一个不错的选择。
我已经做了一些努力来概括我接受任何类型的订购密钥的方法。要做到这一点，我希望得到：
Func<TSource,TKey> TKey Func<TKey,TKey> Func<TSource,TSource,TSource> 由于我只是在我的测试中使用基于1的整数序列，因此满足：
i => i 1 k => k+1 (left,right) => left 这是我的Sort尝试。它将事件缓冲到一个字典中，并尽快将它们刷新到订阅者：
public static IObservable<TSource> Sort<TSource, TKey>
(this IObservable<TSource> source,
Func<TSource, TKey> keySelector,
TKey firstKey,
Func<TKey, TKey> nextKeyFunc)
{
return Observable.Create<TSource>(o =>
{
var nextKey = firstKey;
var buffer = new Dictionary<TKey, TSource>();
return source.Subscribe(i =>
{
if (keySelector(i).Equals(nextKey))
{
nextKey = nextKeyFunc(nextKey);
o.OnNext(i);
TSource nextValue;
while (buffer.TryGetValue(nextKey, out nextValue))
{
buffer.Remove(nextKey);
o.OnNext(nextValue);
nextKey = nextKeyFunc(nextKey);
}
}
else buffer.Add(keySelector(i), i);
});
});
}
我不得不说这是一个非常幼稚的实现。在过去的生产代码中，我已经详细阐述了具体的错误处理，固定大小的缓冲区和超时以防止资源泄漏。但是，它将用于此示例。 ：）
通过这个排序（对不起！），我们现在可以看看处理多个流。
我的第一次尝试是产生一个已经看到所需次数的无序事件流。然后可以对其进行排序。我这样做是通过按键对元素进行分组，使用GroupByUntil来保存每个组，直到捕获到两个元素。然后，每个组是相同密钥的结果流。对于整数事件的简单示例，我可以采用每个组的最后一个元素。但是，我不喜欢这样，因为对于更真实的场景来说，这是很尴尬的，因为每个结果流可能会贡献一些有用的东西。为了感兴趣，我包含了代码。注意，这样可以在第二次尝试和第二次尝试之间共享测试，我接受一个未使用的resultSelector参数：
public static IObservable<TSource> OrderedCollect<TSource, TKey>
(this IObservable<TSource> left,
IObservable<TSource> right,
Func<TSource, TKey> keySelector,
TKey firstKey,
Func<TKey, TKey> nextKeyFunc
Func<TSource,TSource,TSource> resultSelector)
{
return left.Merge(right)
.GroupByUntil(keySelector, x => x.Take(2).LastAsync())
.SelectMany(x => x.LastAsync())
.Sort(keySelector, firstKey, nextKeyFunc);
}
除此之外：你可以破解SelectMany条款来决定如何选择结果。该解决方案在第二次尝试中具有的一个优点是，在具有许多结果流的情况下，更容易看到如何扩展它以选择说，三个结果元组中的前两个到达。
对于这种方法，我独立地对每个流进行排序，然后将Zip结果放在一起。这不仅是一个简单易用的操作，而且以有趣的方式组合每个流的结果也更加容易。为了使测试与我的第一种方法兼容，我选择了resultSelector函数来使用第一个流的事件作为结果，但显然你可以灵活地在你的场景中做一些有用的事情：
public static IObservable<TSource> OrderedCollect<TSource, TKey>
(this IObservable<TSource> left,
IObservable<TSource> right,
Func<TSource, TKey> keySelector,
TKey firstKey,
Func<TKey, TKey> nextKeyFunc,
Func<TSource, TSource, TSource> resultSelector)
{
return Observable.Zip(
left.Sort(keySelector, firstKey, nextKeyFunc),
right.Sort(keySelector, firstKey, nextKeyFunc),
resultSelector);
}
除此之外：不难看出这段代码如何扩展到接受任意数量的输入流的更一般的情况，但正如之前所提到的，使用Zip使得它在阻塞时非常不灵活一个给定的密钥，直到所有流的结果都在。
最后，这是我的测试回应你的示例场景。要运行这些，请导入nuget包rx-testing和nunit，并将上面的实现放入静态类中：
public class ReorderingEventsTests : ReactiveTest
{
[Test]
public void ReorderingTest1()
{
var scheduler = new TestScheduler();
var s1 = scheduler.CreateColdObservable(
OnNext(100, 1),
OnNext(200, 2),
OnNext(400, 3),
OnNext(500, 4));
var s2 = scheduler.CreateColdObservable(
OnNext(100, 1),
OnNext(200, 3),
OnNext(300, 2),
OnNext(500, 4));
var results = scheduler.CreateObserver<int>();
s1.OrderedCollect(
right: s2,
keySelector: i => i,
firstKey: 1,
nextKeyFunc: i => i + 1,
resultSelector: (left,right) => left).Subscribe(results);
scheduler.Start();
results.Messages.AssertEqual(
OnNext(100, 1),
OnNext(300, 2),
OnNext(400, 3),
OnNext(500, 4));
}
[Test]
public void ReorderingTest2()
{
var scheduler = new TestScheduler();
var s1 = scheduler.CreateColdObservable(
OnNext(100, 1),
OnNext(200, 2),
OnNext(300, 3),
OnNext(400, 4));
var s2 = scheduler.CreateColdObservable(
OnNext(100, 4),
OnNext(200, 3),
OnNext(300, 2),
OnNext(400, 1));
var results = scheduler.CreateObserver<int>();
s1.OrderedCollect(
right: s2,
keySelector: i => i,
firstKey: 1,
nextKeyFunc: i => i + 1,
resultSelector: (left, right) => left).Subscribe(results);
scheduler.Start();
results.Messages.AssertEqual(
OnNext(400, 1),
OnNext(400, 2),
OnNext(400, 3),
OnNext(400, 4));
}
}
最后的评论，因为我讨厌在代码中重复自己，这是一个调整，避免了我在第二种方法中调用Sort的重复方式。我没有将它包含在主体内，以避免让不熟悉curry的读者感到困惑：
public static IObservable<TSource> OrderedCollect<TSource, TKey>
(this IObservable<TSource> left,
IObservable<TSource> right,
Func<TSource, TKey> keySelector,
TKey firstKey,
Func<TKey, TKey> nextKeyFunc,
Func<TSource, TSource, TSource> resultSelector)
{
Func<IObservable<TSource>, IObservable<TSource>> curriedSort =
events => events.Sort(keySelector, firstKey, nextKeyFunc);
return Observable.Zip(
curriedSort(left),
curriedSort(right),
resultSelector);
}