密封类如何作为自身IObservable<AnotherClass>属性的观察者？

嘿，这个问题我碰到过好多次了——密封类没法继承那些带虚OnNext方法的抽象观察者类，但咱们完全有办法绕开这个限制，用Rx的原生机制就能搞定，给你几个实用的方案：

方案1：直接在订阅时传入OnNext回调（最简洁） #

如果你的逻辑比较简单，直接在订阅IObservable时，用lambda表达式把OnNext的逻辑指向你的自定义Method1就行，完全不用实现任何观察者接口：

public sealed class YourSealedClass
{
    private IObservable<AnotherClass> _observable;
    // 记得保存订阅实例，方便后续取消避免内存泄漏
    private IDisposable _subscription;

    public YourSealedClass(IObservable<AnotherClass> observable)
    {
        _observable = observable;
        // 直接订阅，把OnNext绑定到Method1
        _subscription = _observable.Subscribe(
            onNext: data => Method1(data),
            onError: ex => 
            {
                // 这里可以添加错误处理逻辑，比如记录日志
                Console.WriteLine($"Observable error: {ex.Message}");
            },
            onCompleted: () => 
            {
                // 处理流完成的逻辑
                Console.WriteLine("Observable stream completed");
            }
        );
    }

    private void Method1(AnotherClass data)
    {
        // 这里写你的自定义业务逻辑
        Console.WriteLine($"Received data: {data.ToString()}");
    }

    // 可选：在类的生命周期结束时取消订阅
    public void Dispose()
    {
        _subscription?.Dispose();
    }
}

方案2：用Observer.Create创建独立观察者实例 #

如果你的错误处理、完成逻辑比较复杂，不想堆在lambda里，可以用Observer.Create创建一个观察者实例，把各个回调拆分到单独的方法里，代码结构更清晰：

public sealed class YourSealedClass
{
    private IObservable<AnotherClass> _observable;
    private IDisposable _subscription;

    public YourSealedClass(IObservable<AnotherClass> observable)
    {
        _observable = observable;
        // 创建观察者实例，绑定各个回调方法
        var observer = Observer.Create<AnotherClass>(
            OnNextHandler,
            OnErrorHandler,
            OnCompletedHandler
        );
        _subscription = _observable.Subscribe(observer);
    }

    // 专门处理OnNext的方法，直接调用你的Method1
    private void OnNextHandler(AnotherClass data)
    {
        Method1(data);
    }

    private void OnErrorHandler(Exception ex)
    {
        // 独立的错误处理逻辑
        // 比如写入日志系统、触发告警等
    }

    private void OnCompletedHandler()
    {
        // 独立的流完成处理逻辑
        // 比如清理资源、通知上层等
    }

    private void Method1(AnotherClass data)
    {
        // 自定义业务逻辑
    }

    public void Cleanup()
    {
        _subscription?.Dispose();
    }
}

方案3：实现IObserver接口（结构化最强） #

密封类虽然不能继承类，但完全可以实现接口！你可以让密封类直接实现IObserver<T>接口，然后把自己作为观察者传入订阅方法，这种方式适合需要把观察者逻辑完全封装在类内部的场景：

public sealed class YourSealedClass : IObserver<AnotherClass>
{
    private IObservable<AnotherClass> _observable;
    private IDisposable _subscription;

    public YourSealedClass(IObservable<AnotherClass> observable)
    {
        _observable = observable;
        // 把当前实例作为观察者订阅
        _subscription = _observable.Subscribe(this);
    }

    // 实现IObserver<T>的OnNext方法，直接调用Method1
    public void OnNext(AnotherClass value)
    {
        Method1(value);
    }

    // 实现错误处理方法
    public void OnError(Exception error)
    {
        // 错误处理逻辑
    }

    // 实现完成处理方法
    public void OnCompleted()
    {
        // 完成处理逻辑
    }

    private void Method1(AnotherClass data)
    {
        // 自定义业务逻辑
    }

    public void Dispose()
    {
        _subscription?.Dispose();
    }
}

关键提醒 #

不管用哪种方案，一定要保存IDisposable类型的订阅实例，并在类的生命周期结束时调用Dispose()取消订阅，否则会导致内存泄漏——因为Observable会一直持有对你的密封类的引用，直到流结束。

内容的提问来源于stack exchange，提问作者Anjali Iyengar