如何清除ReplaySubject上的缓冲区？
我需要定期清除缓冲区（在我的情况下作为日常事件的结束），以防止ReplaySubject不断增长并最终占用所有内存。
理想情况下，我希望保持相同的ReplaySubject，因为客户端订阅仍然很好。
感谢。
答案 0 :(得分：11)
ReplaySubject没有提供清除缓冲区的方法，但有几种重载以不同方式约束其缓冲区：
TimeSpan
这是一个非常有趣的问题 - 我决定看看使用现有的主题和运算符来实现{<1}}你可以清楚的变体是多么容易（因为这些是相当的强大的）。事实证明这是相当简单的。
我通过内存分析器运行它来检查它是否正确。调用ReplaySubject来刷新缓冲区，否则它就像常规无界Clear()一样：
ReplaySubject尊重常规规则（与任何public class RollingReplaySubject<T> : ISubject<T>
{
private readonly ReplaySubject<IObservable<T>> _subjects;
private readonly IObservable<T> _concatenatedSubjects;
private ISubject<T> _currentSubject;
public RollingReplaySubject()
{
_subjects = new ReplaySubject<IObservable<T>>(1);
_concatenatedSubjects = _subjects.Concat();
_currentSubject = new ReplaySubject<T>();
_subjects.OnNext(_currentSubject);
}
public void Clear()
{
_currentSubject.OnCompleted();
_currentSubject = new ReplaySubject<T>();
_subjects.OnNext(_currentSubject);
}
public void OnNext(T value)
{
_currentSubject.OnNext(value);
}
public void OnError(Exception error)
{
_currentSubject.OnError(error);
}
public void OnCompleted()
{
_currentSubject.OnCompleted();
_subjects.OnCompleted();
// a quick way to make the current ReplaySubject unreachable
// except to in-flight observers, and not hold up collection
_currentSubject = new Subject<T>();
}
public IDisposable Subscribe(IObserver<T> observer)
{
return _concatenatedSubjects.Subscribe(observer);
}
}
一样）并且不会同时调用此类的方法 - 包括Subject。如果需要，您可以轻松添加同步锁。
它通过在主ReplaySubject中嵌套一系列ReplaySubject来工作。外部ReplaySubject（Clear()）拥有一个内部ReplaySubject（_subjects）的缓冲区，并在构造时填充。
_currentSubject方法调用OnXXX ReplaySubject。
观察者订阅了嵌套ReplaySubjects的连续投影（保存在_currentSubject中）。由于_concatenatedSubjects的缓冲区大小仅为1，因此新订阅者只能获取最新_subjects以后的事件。
每当我们需要清除缓冲区＆＃34;时，现有的ReplaySubject为_currentSubject，并且新的ReplaySubject会添加到OnCompleted并成为新的{{1} }}
根据@Brandon的建议，我创建了一个_subjects版本，它使用_currentSubject或输入流来表示缓冲区清除。我在这里为此创建了一个要点：https://gist.github.com/james-world/c46f09f32e2d4f338b07
答案 1 :(得分：0)
您可能已经拥有Observable数据源，在这种情况下，这是另一种解决方案。这个使用现有RX结构的组合，而不是建立我个人所担心的自己的ISubject。
public class ClearableReplaySubject<TSource, TClearTrigger> : IConnectableObservable<TSource>
{
private readonly IConnectableObservable<IObservable<TSource>> _underlying;
private readonly SerialDisposable _replayConnectDisposable = new SerialDisposable();
public ClearableReplaySubject(IObservable<TSource> src, IObservable<TClearTrigger> clearTrigger)
{
_underlying = clearTrigger.Select(_ => Unit.Default).StartWith(Unit.Default)
.Select(_ =>
{
var underlyingReplay = src.Replay();
_replayConnectDisposable.Disposable = underlyingReplay.Connect();
return underlyingReplay;
})
.Replay(1);
}
public IDisposable Subscribe(IObserver<TSource> observer)
{
return _underlying.Switch().Subscribe(observer);
}
public IDisposable Connect()
{
return new CompositeDisposable(_underlying.Connect(), _replayConnectDisposable.Disposable);
}
}
如果您将以下扩展方法添加到ObservableEx：
public static class ObservableEx
{
public static IConnectableObservable<TItem> ReplayWithReset<TItem, TReset>(this IObservable<TItem> src, IObservable<TReset> resetTrigger)
{
return new ClearableReplaySubject<TItem, TReset>(src, resetTrigger);
}
}
然后您可以获取源并使用重置触发器Observable添加 .ReplayWithReset（...）。这可能是一个计时器或其他什么。
var replay = sourceObservable.ReplayWithReset(triggerObservable);
var connection = replay.Connect();
连接的行为方式与重播方式相同。
答案 2 :(得分：0)
我不了解c＃，但是我设法在重放主题rxdart中完成了它。 至于replaysubject，它使用队列来缓存事件，所以我 修改了replaysubject类。
原始重播主题：
class ReplaySubject<T> extends Subject<T> implements ReplayStream<T> {
final Queue<T> _queue;
final int _maxSize;
/// Constructs a [ReplaySubject], optionally pass handlers for
/// [onListen], [onCancel] and a flag to handle events [sync].
///
/// See also [StreamController.broadcast]
factory ReplaySubject({
int maxSize,
void Function() onListen,
void Function() onCancel,
bool sync = false,
}) {
// ignore: close_sinks
final controller = StreamController<T>.broadcast(
onListen: onListen,
onCancel: onCancel,
sync: sync,
);
final queue = Queue<T>();
return ReplaySubject<T>._(
controller,
Rx.defer<T>(
() => controller.stream.startWithMany(queue.toList(growable: false)),
reusable: true,
),
queue,
maxSize,
);
}
ReplaySubject._(
StreamController<T> controller,
Stream<T> stream,
this._queue,
this._maxSize,
) : super(controller, stream);
@override
void onAdd(T event) {
if (_queue.length == _maxSize) {
_queue.removeFirst();
}
_queue.add(event);
}
@override
List<T> get values => _queue.toList(growable: false);
}
修改后的重播主题：
class ModifiedReplaySubject<T> extends Subject<T> implements ReplayStream<T> {
final List<T> _list;
final int _maxSize;
/// Constructs a [ModifiedReplaySubject], optionally pass handlers for
/// [onListen], [onCancel] and a flag to handle events [sync].
///
/// See also [StreamController.broadcast]
factory ModifiedReplaySubject({
int maxSize,
void Function() onListen,
void Function() onCancel,
bool sync = false,
}) {
// ignore: close_sinks
final controller = StreamController<T>.broadcast(
onListen: onListen,
onCancel: onCancel,
sync: sync,
);
final queue = List<T>();
return ModifiedReplaySubject<T>._(
controller,
Rx.defer<T>(
() => controller.stream.startWithMany(queue.toList(growable: false)),
reusable: true,
),
queue,
maxSize,
);
}
ModifiedReplaySubject._(
StreamController<T> controller,
Stream<T> stream,
this._list,
this._maxSize,
) : super(controller, stream);
@override
void onAdd(T event) {
if (_list.length == _maxSize) {
_list.removeAt(0);
}
_list.add(event);
}
void onRemove(T event) {
_list.remove(event);
}
@override
List<T> get values => _list.toList(growable: false);
}