C# 使密封类成为其自身可观察对象的观察者<；T>；财产

我有一门封闭的课。它有一个属性 "

private IObservable可观察

"

我想让这个类成为一个观察者，并监视上面属性的变化

每当此属性发生更改时，我都要调用onNext（）

我想在.onNext（）中调用自定义method1（）。比如onNext（调用Method1（传递可观察数据））。 因为这是一个密封的类，所以我不能像在许多示例中一样使用Virtual onNext（）

我如何实现这些目标？

实现

IObserver

并订阅可观察对象

public sealed class AnObserver : IObserver<AnotherClass>
{
    private readonly IObservable<AnotherClass> observable;

    public AnObserver()
    {
        observable = ...;
        observable.Subscribe(this);
    }

    void IObserver<AnotherClass>.OnCompleted() { }

    void IObserver<AnotherClass>.OnError(Exception error) { }

    void IObserver<AnotherClass>.OnNext(AnotherClass value)
    {
        Method1(value);
    }

    public void Method1(AnotherClass value)
    {
       ...
    }
}

公共密封类AnObserver:IObserver
{
私有只读可观察；
公共AnObserver（）
{
可观察=。。。；
可观察。订阅（本）；
}
void IObserver.OnCompleted（）{}
void IObserver.OnError（异常错误）{}
void IObserver.OnNext（另一个类值）
{
方法1（价值）；
}
public void Method1（另一个类值）
{
...
}
}

实现

IObserver

并订阅可观察到的

public sealed class AnObserver : IObserver<AnotherClass>
{
    private readonly IObservable<AnotherClass> observable;

    public AnObserver()
    {
        observable = ...;
        observable.Subscribe(this);
    }

    void IObserver<AnotherClass>.OnCompleted() { }

    void IObserver<AnotherClass>.OnError(Exception error) { }

    void IObserver<AnotherClass>.OnNext(AnotherClass value)
    {
        Method1(value);
    }

    public void Method1(AnotherClass value)
    {
       ...
    }
}

公共密封类AnObserver:IObserver
{
私有只读可观察；
公共AnObserver（）
{
可观察=。。。；
可观察。订阅（本）；
}
void IObserver.OnCompleted（）{}
void IObserver.OnError（异常错误）{}
void IObserver.OnNext（另一个类值）
{
方法1（价值）；
}
public void Method1（另一个类值）
{
...
}
}

以下是我将如何应对这种情况

public sealed class ThisClass : IDisposable
{
    private readonly IObservable<AnotherClass> observable;
    private readonly IDisposable subscription;

    public ThisClass()
    {
        observable = ...;
        subscription = observable.Subscribe(x => Method1(x));
    }

    private void Method1(AnotherClass value)
    {
       ...
    }

    private bool disposedValue = false;

    void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                subscription.Dispose();
            }
            disposedValue = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
    }
}

公共密封类此类：IDisposable
{
私有只读可观察；
私人只读IDisposable订阅；
公共类（）
{
可观察=。。。；
订阅=可观察。订阅（x=>Method1（x））；
}
私有void方法1（另一个类值）
{
...
}
private bool disposedValue=false；
无效处置（bool处置）
{
如果（！disposedValue）
{
如果（处置）
{
subscription.Dispose（）；
}
disposedValue=true；
}
}
公共空间处置（）
{
处置（真实）；
}
}

---

这不会将任何不必要的东西暴露给外部世界，并在处置时进行清理。

以下是我将如何处理这种情况

public sealed class ThisClass : IDisposable
{
    private readonly IObservable<AnotherClass> observable;
    private readonly IDisposable subscription;

    public ThisClass()
    {
        observable = ...;
        subscription = observable.Subscribe(x => Method1(x));
    }

    private void Method1(AnotherClass value)
    {
       ...
    }

    private bool disposedValue = false;

    void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                subscription.Dispose();
            }
            disposedValue = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
    }
}

公共密封类此类：IDisposable
{
私有只读可观察；
私人只读IDisposable订阅；
公共类（）
{
可观察=。。。；
订阅=可观察。订阅（x=>Method1（x））；
}
私有void方法1（另一个类值）
{
...
}
private bool disposedValue=false；
无效处置（bool处置）
{
如果（！disposedValue）
{
如果（处置）
{
subscription.Dispose（）；
}
disposedValue=true；
}
}
公共空间处置（）
{
处置（真实）；
}
}

---

这不会将任何不必要的内容暴露给外部世界，并在dispose时进行清理。

请避免实现

IObserver

-它通常会出错。这样做，在本例中，您已经向外部世界公开了类的内部工作。当您调用

Subscribe

时，代码中还有一个悬空的

IDisposable

。这将迫使类实现

IDisposable

以进行清理。请避免实现

IObserver

-它通常会出错。这样做，在本例中，您已经向外部世界公开了类的内部工作。当您调用

Subscribe

时，代码中还有一个悬空的

IDisposable

。这将迫使类实现

IDisposable

来进行清理。