C# 处理生成的可观察项目

我有一个

IObservable

，它可以生成可丢弃的物品，并且在其生命周期内可能会生成无限数量的物品。因此，我希望在每次生成新项目时都处理最后一个项目，因此操作员将不处理该项目。是否有其他Rx.NET运营商可以完成此功能？

我在Shlomo遇到过，并根据自己的目的对其进行了调整：

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:IDisposable，IObservable其中T:IDisposable
{
私有IDisposable订阅{get；}
私有IObservable源{get；}
公共T值{get；私有集；}
公共处置属性（IObservable源，T defaultValue=default）
{
值=默认值；
来源=来源；
订阅=源。订阅（t=>
{
值？.Dispose（）；
值=t；
});
}
public void Dispose（）=>Subscription.Dispose（）；
/// 
public IDisposable Subscribe（IObserver-observer）=>Source.Subscribe（observer）；
}

---

现在，每当我需要此功能时，我只使用一个

DisposerProperty

，而不是直接订阅可观察对象。

如果您有一个

IObservable源

，则执行此操作以自动处理以前的值，并在序列结束时进行清理：

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

IObservable查询=
创建（o=>
{
var serial=新的SerialDisposable（）；
返回新的CompositeDisposable(
source.Do（x=>serial.Disposable=x）.Subscribe（o），
序列号）；
})

这是一个

disposeprovous

操作符，基于Enigmativity的稍微修改版本

///处理可观察序列的前一个元素。最后
///元素在可观察序列完成时被释放。
公共静态IObservable DisposePrevious（此IObservable源）
其中T:IDisposable
{
返回可观察的。使用（（）=>new SerialDisposable（），serial=>
Do（x=>serial.Disposable=x））；
}

班级

表示一个一次性资源，其基础一次性资源可以被另一个一次性资源替换，从而导致自动处置以前的基础一次性资源

---

这是一个坏主意，有一种方法可以用现有的运算符和类型来实现这一点。@Enigmativity为什么这样不好？比如，这会以什么方式适得其反呢？实现自己的可观察类很难做到正确。除非你们有认真的测试，否则我不会使用它。若源代码是主题的话，它似乎也可以正常工作。我可以使用Subject还是必须先转换为observable？我把它作为subject.Do（x=>serial.Disposable=x）.Subscribe（o），@XavierJohn-subject是可观察的，也是观察者。这就是他们。所以不需要转换。

/// <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));
}