我尝试使用Rx，因为它似乎非常适合我们的领域，但学习曲线让我感到意外。
我需要将历史价格数据与实时价格数据结合在一起。
我试图采用通常的方法将这种做法转换为Rx的语言：
我有这个令人作呕和不正确的稻草人代码，这似乎适用于我写过的天真测试案例：
IConnectableObservable<Tick> live = liveService
.For(symbol)
.Replay(/* Some appropriate buffer size */);
live.Connect();
IObservable<Tick> historical = historyService.For(since, symbol);
return new[] {historical, live}
.Concat()
.Where(TicksAreInChronologicalOrder());
private static Func1<Tick,bool> TicksAreInChronologicalOrder()
{
// Some stateful predicate comparing the timestamp of this tick
// to the timestamp of the last tick we saw
}
这有一些缺点
live.SkipWhile(tick => tick.Timestamp < /* lazily get last timestamp in historical data */)。 Wait(this IObservable<TSource>)在这里有用吗？必须有一个更好的方法来做到这一点，但我仍然在等待我的大脑像R一样去研究Rx。
我考虑解决的另一个选择1.是编写我自己的Rx扩展，它是一个ISubject，它将消息排队，直到它获得第一个订阅者（之后拒绝订阅者？）。也许这是要走的路？
答案 0 :(得分：1)
如果您的历史数据和实时数据都是基于时间或调度程序的，也就是说，事件流会随着时间的推移而显示：
|----------------------------------------------------> time
h h h h h h historical
l l l l l l live
您可以使用简单的TakeUntil构造：
var historicalStream = <fetch historical data>;
var liveStream = <fetch live data>;
var mergedWithoutOverlap =
// pull from historical
historicalStream
// until we start overlapping with live
.TakeUntil(liveStream)
// then continue with live data
.Concat(liveStream);
如果您同时获得所有历史数据，例如IEnumerable<T>，则可以使用StartWith和其他逻辑的组合：
var historicalData = <get IEnumerable of tick data>;
var liveData = <get IObservable of tick data>;
var mergedWithOverlap =
// the observable is the "long running" feed
liveData
// But we'll inject the historical data in front of it
.StartWith(historicalData)
// Perform filtering based on your needs
.Where( .... );
答案 1 :(得分：1)
如下：
public static IObservable<T> CombineWithHistory<T, TSelectorResult>(this IObservable<T> live, IObservable<T> history, Func<T, TSelectorResult> selector)
{
var replaySubject = new ReplaySubject<T>();
live.Subscribe(replaySubject);
return history.Concat(replaySubject).Distinct(selector);
}
这使用序列id和distinct来过滤重复项。
以及相应的测试：
var testScheduler = new TestScheduler();
var history = testScheduler.CreateColdObservable(
OnNext(1L, new PriceTick { PriceId = 1 }),
OnNext(2L, new PriceTick { PriceId = 2 }),
OnNext(3L, new PriceTick { PriceId = 3 }),
OnNext(4L, new PriceTick { PriceId = 4 }),
OnCompleted(new PriceTick(), 5L));
var live = testScheduler.CreateHotObservable(
OnNext(1L, new PriceTick { PriceId = 3 }),
OnNext(2L, new PriceTick { PriceId = 4 }),
OnNext(3L, new PriceTick { PriceId = 5 }),
OnNext(4L, new PriceTick { PriceId = 6 }),
OnNext(5L, new PriceTick { PriceId = 7 }),
OnNext(6L, new PriceTick { PriceId = 8 }),
OnNext(7L, new PriceTick { PriceId = 9 })
);
live.Subscribe(pt => Console.WriteLine("Live {0}", pt.PriceId));
history.Subscribe(pt => Console.WriteLine("Hist {0}", pt.PriceId), () => Console.WriteLine("C"));
var combined = live.CombineWithHistory(history, t => t.PriceId);
combined.Subscribe(pt => Console.WriteLine("Combined {0}", pt.PriceId));
testScheduler.AdvanceTo(6L);
如果您执行此测试，则合并后会发出价格为1到8的价格。
答案 2 :(得分：1)
为了记录，这是我最后所做的。我仍然是一个Rx学习者，并且返回.Net，最后一次见到2.0版本。非常感谢所有的反馈。
下面使用的Ticks对象可能包含一个或多个刻度值。历史数据服务以多个Ticks返回数据。
public class HistoricalAndLivePriceFeed : IPriceFeed
{
private readonly IPriceFeed history;
private readonly IPriceFeed live;
private readonly IClock clock;
public HistoricalAndLivePriceFeed(IPriceFeed history, IPriceFeed live)
: this(history, live, new RealClock())
{
}
public HistoricalAndLivePriceFeed(IPriceFeed history, IPriceFeed live, IClock clock)
{
this.history = history;
this.live = live;
this.clock = clock;
}
public IObservable<Ticks> For(DateTime since, ISymbol symbol)
{
return Observable.Create<Ticks>(observer =>
{
var liveStream = Buffer<Ticks>.StartBuffering(live.For(since, symbol));
var definitelyInHistoricalTicks = clock.Now;
// Sleep to make sure that historical data overlaps our live data
// If we ever use a data provider with less fresh historical data, we may need to rethink this
clock.Wait(TimeSpan.FromSeconds(1));
var liveStreamAfterEndOfHistoricalTicks = liveStream
.SkipWhile(ticks => ticks.LastTimestamp <= definitelyInHistoricalTicks)
.Select(ticks => ticks.RemoveBefore(definitelyInHistoricalTicks + 1));
var subscription = history.For(since, symbol)
.Select(historicalTicks => historicalTicks.RemoveAtOrAfter(definitelyInHistoricalTicks + 1))
.Concat(liveStreamAfterEndOfHistoricalTicks)
.Subscribe(observer);
return liveStream.And(subscription);
});
}
}
public static class CompositeDisposableExtensions
{
public static CompositeDisposable And(this IDisposable disposable, Action action)
{
return And(disposable, Disposable.Create(action));
}
public static CompositeDisposable And(this IDisposable disposable, IDisposable other)
{
return new CompositeDisposable(disposable, other);
}
}
哪个使用这个Rx代码，我仍然不太相信：
using System;
using System.Collections.Generic;
using System.Reactive.Disposables;
using System.Reactive.Subjects;
namespace My.Rx
{
/// <summary>
/// Buffers values from an underlying observable when no observers are subscribed.
///
/// On Subscription, any buffered values will be replayed.
///
/// Only supports one observer for now.
///
/// Buffer is an ISubject for convenience of implementation but IObserver methods
/// are hidden. It is not intended that Buffer should be used as an IObserver,
/// except through StartBuffering() and it is dangerous to do so because none of
/// the IObserver methods check whether Buffer has been disposed.
/// </summary>
/// <typeparam name="TSource"></typeparam>
public class Buffer<TSource> : ISubject<TSource>, IDisposable
{
private readonly object gate = new object();
private readonly Queue<TSource> queue = new Queue<TSource>();
private bool isDisposed;
private Exception error;
private bool stopped;
private IObserver<TSource> observer = null;
private IDisposable subscription;
public static Buffer<TSource> StartBuffering(IObservable<TSource> observable)
{
return new Buffer<TSource>(observable);
}
private Buffer(IObservable<TSource> observable)
{
subscription = observable.Subscribe(this);
}
void IObserver<TSource>.OnNext(TSource value)
{
lock (gate)
{
if (stopped) return;
if (IsBuffering)
queue.Enqueue(value);
else
observer.OnNext(value);
}
}
void IObserver<TSource>.OnError(Exception error)
{
lock (gate)
{
if (stopped) return;
if (IsBuffering)
this.error = error;
else
observer.OnError(error);
stopped = true;
}
}
void IObserver<TSource>.OnCompleted()
{
lock (gate)
{
stopped = true;
}
}
public IDisposable Subscribe(IObserver<TSource> observer)
{
lock (gate)
{
if (isDisposed)
throw new ObjectDisposedException(string.Empty);
if (this.observer != null)
throw new NotImplementedException("A Buffer can currently only support one observer at a time");
while(!queue.IsEmpty())
{
observer.OnNext(queue.Dequeue());
}
if (error != null)
observer.OnError(error);
else if (stopped)
observer.OnCompleted();
this.observer = observer;
return Disposable.Create(() =>
{
lock (gate)
{
// Go back to buffering
this.observer = null;
}
});
}
}
private bool IsBuffering
{
get { return observer == null; }
}
public void Dispose()
{
lock (gate)
{
subscription.Dispose();
isDisposed = true;
subscription = null;
observer = null;
}
}
}
}
通过了这些测试（我还没有考虑过检查线程的安全性）：
private static readonly Exception exceptionThrownFromUnderlying = new Exception("Hello world");
[Test]
public void ReplaysBufferedValuesToFirstSubscriber()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
underlying.OnNext(1);
underlying.OnNext(2);
var observed = new List<int>();
buffer.Subscribe(Observer.Create<int>(observed.Add));
Assert.That(observed, Is.EquivalentTo(new []{1,2}));
}
[Test]
public void PassesNewValuesToObserver()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
var observed = new List<int>();
buffer.Subscribe(Observer.Create<int>(observed.Add));
underlying.OnNext(1);
underlying.OnNext(2);
Assert.That(observed, Is.EquivalentTo(new[] { 1, 2 }));
}
[Test]
public void DisposesOfSubscriptions()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
var observed = new List<int>();
buffer.Subscribe(Observer.Create<int>(observed.Add))
.Dispose();
underlying.OnNext(1);
Assert.That(observed, Is.Empty);
}
[Test]
public void StartsBufferingAgainWhenSubscriptionIsDisposed()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
// These should be buffered
underlying.OnNext(1);
underlying.OnNext(2);
var firstSubscriptionObserved = new List<int>();
using (buffer.Subscribe(Observer.Create<int>(firstSubscriptionObserved.Add)))
{
// Should be passed through to first subscription
underlying.OnNext(3);
}
Assert.That(firstSubscriptionObserved, Is.EquivalentTo(new[] { 1, 2, 3 }));
// First subscription has been disposed-
// we should be back to buffering again
underlying.OnNext(4);
underlying.OnNext(5);
var secondSubscriptionObserved = new List<int>();
using (buffer.Subscribe(Observer.Create<int>(secondSubscriptionObserved.Add)))
{
// Should be passed through to second subscription
underlying.OnNext(6);
}
Assert.That(secondSubscriptionObserved, Is.EquivalentTo(new[] { 4, 5 ,6}));
}
[Test]
public void DoesNotSupportTwoConcurrentObservers()
{
// Use .Publish() if you need to do this
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
buffer.Subscribe(Observer.Create<int>(i => { }));
Assert.Throws<NotImplementedException>(() => buffer.Subscribe(Observer.Create<int>(i => { })));
}
[Test]
public void CannotBeUsedAfterDisposal()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
buffer.Dispose();
Assert.Throws<ObjectDisposedException>(() => buffer.Subscribe(Observer.Create<int>(i => { })));
}
[Test]
public void ReplaysBufferedError()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
underlying.OnNext(1);
underlying.OnError(exceptionThrownFromUnderlying);
var observed = new List<int>();
Exception foundException = null;
buffer.Subscribe(
observed.Add,
e => foundException = e);
Assert.That(observed, Is.EquivalentTo(new []{1}));
Assert.That(foundException, Is.EqualTo(exceptionThrownFromUnderlying));
}
[Test]
public void ReplaysBufferedCompletion()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
underlying.OnNext(1);
underlying.OnCompleted();
var observed = new List<int>();
var completed = false;
buffer.Subscribe(
observed.Add,
() => completed=true);
Assert.That(observed, Is.EquivalentTo(new[] { 1 }));
Assert.True(completed);
}
[Test]
public void ReplaysBufferedErrorToSubsequentObservers()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
underlying.OnNext(1);
underlying.OnError(exceptionThrownFromUnderlying);
// Drain value queue
using (buffer.Subscribe(Observer.Create<int>(i => { }, e => { }))) ;
var observered = new List<int>();
Exception exceptionEncountered = null;
using (buffer.Subscribe(Observer.Create<int>(observered.Add, e=>exceptionEncountered=e)));
Assert.That(observered, Is.Empty);
Assert.That(exceptionEncountered, Is.EqualTo(exceptionThrownFromUnderlying));
}
[Test]
public void ReplaysBufferedCompletionToSubsequentObservers()
{
var underlying = new Subject<int>();
var buffer = Buffer<int>.StartBuffering(underlying);
underlying.OnNext(1);
underlying.OnCompleted();
// Drain value queue
using (buffer.Subscribe(Observer.Create<int>(i => { }))) ;
var observered = new List<int>();
var completed = false;
using (buffer.Subscribe(Observer.Create<int>(observered.Add, ()=>completed=true)));
Assert.That(observered, Is.Empty);
Assert.True(completed);
}
[Test]
public void DisposingOfBufferDisposesUnderlyingSubscription()
{
var underlyingSubscriptionWasDisposed = false;
var underlying = Observable.Create<int>(observer => Disposable.Create(() => underlyingSubscriptionWasDisposed= true ));
var buffer = Buffer<int>.StartBuffering(underlying);
buffer.Dispose();
Assert.True(underlyingSubscriptionWasDisposed);
}
答案 3 :(得分：0)
在记忆和交易重叠（正确性）方面的便捷方式 等待您的反馈：
var tradeIds = new HashSet<string>();
var replayQuotationTrades = new ReplaySubject<IntradayTrade>();
var replaySubscription = _quotationTrades.Subscribe(replayQuotationTrades);
return _historyTrades
.DelaySubscription(TimeSpan.FromMilliseconds(500), _backgroundScheduler)
.Do(t => tradeIds.Add(t.TradeId))
.Finally(() => DisposeAndCompleteReplayStream(replaySubscription, replayQuotationTrades))
.Concat(replayQuotationTrades.Where(t => !tradeIds.Contains(t.TradeId)))
.Finally(tradeIds.Clear)
.Concat(_quotationTrades)
.Subscribe(observer);