Question

我有一个IObservable生成一次性的项目，并且它会在其生命周期内生成可能无限数量的项目。因此，我想在每次生成新项目时处理最后一项，因此Using运算符不适用于此。是否有一个可以完成此功能的不同Rx.NET运算符？

Answer 1

如果你有IObservable<IDisposable> source，那么这样做是为了自动处理前一个值并在序列结束时进行清理：

IObservable<IDisposable> query =
    Observable.Create<IDisposable>(o =>
    {
        var serial = new SerialDisposable();
        return new CompositeDisposable(
            source.Do(x => serial.Disposable = x).Subscribe(o),
            serial);
    })

Answer 2

我遇到了Shlomo的this answer并根据我自己的目的进行了调整：

public class DisposerProperty<T> : IDisposable, IObservable<T> where T : IDisposable
{
    private IDisposable Subscription { get; }
    private IObservable<T> Source { get; }

    public T Value { get; private set; }

    public DisposerProperty(IObservable<T> source, T defaultValue = default)
    {
        Value = defaultValue;
        Source = source;
        Subscription = source.Subscribe(t =>
                                        {
                                            Value?.Dispose();
                                            Value = t;
                                        });
    }

    public void Dispose() => Subscription.Dispose();

    /// <inheritdoc />
    public IDisposable Subscribe(IObserver<T> observer) => Source.Subscribe(observer);
}

现在，每当我想要这个功能时，我只使用DisposerProperty<T>而不是直接订阅observable。

Answer 3

这是一个DisposePrevious运算符，它是对Enigmativity的solution的略微修改。

/// <summary>Disposes the previous element of an observable sequence. The last
/// element is disposed when the observable sequence completes.</summary>
public static IObservable<T> DisposePrevious<T>(this IObservable<T> source)
    where T : IDisposable
{
    return Observable.Using(() => new SerialDisposable(), serial =>
        source.Do(x => serial.Disposable = x));
}

SerialDisposable类...

表示一个可使用资源，其基础可使用资源可以被另一个可使用资源代替，从而自动处置先前的基础可使用资源。

处置生成的可观察物品

3 个答案: