.net core 未多次调用Observer OnError委托

您好，我正在试图理解为什么

OnError

不会每次都被

观察者调用。
尝试调试在my
IOBservable
实现中调用的
OneError
时，调试器会经过

可观察的实施

public class Reactive:IStorage,IObservable<SquareResult>
        {
            private object @lock = new object();
            private List<IObserver<SquareResult>> observers = new List<IObserver<SquareResult>>();


            public static Reactive Create()
            {
                return new Reactive();
            }

            public void Enqueue(SquareResult square)
            {
                lock (@lock)
                {
                    foreach (var item in observers)
                    {
                        if (square.Result < 0)
                        {
                            item.OnError(new InvalidSquareException());
                        }
                        else
                        item.OnNext(square);
                    }
                }
            }
            public void EndStoring()
            {
                this.observers.ForEach(obs => obs.OnCompleted());
            }

            public IDisposable Subscribe(IObserver<SquareResult> observer)
            {
                if (!this.observers.Contains(observer))
                {
                    this.observers.Add(observer);
                }
                return new Unsubscriber(observer, this.observers);
            }

            public class Unsubscriber : IDisposable
            {
                private List<IObserver<SquareResult>> observers;
                private IObserver<SquareResult> observer;

                public Unsubscriber(IObserver<SquareResult>obs,List<IObserver<SquareResult>>observers)
                {
                    this.observer = obs;
                    this.observers = observers;
                }

                public void Dispose()
                {
                    if (this.observer == null)
                    {
                        return;
                    }
                    this.observers.Remove(this.observer);
                }
            }
        }

所以基本上，如果我从某个地方调用
myobservable.OnError（new exception（））
几次，
消费者的回调只调用一次，我不明白为什么

示例：

observable.OnError（新异常（））；
observable.OnError（新异常（））

Observer.OnError执行

public void OnError(Exception ex)
{
  Console.WriteLine(ex.Message);
 }

我的代码中的上述示例只打印一次异常消息。
允许0个或多个
OnNext
通知，然后是一个
OnCompleted
或一个
OnError
通知，终止可观察对象。一旦可观察对象被终止（在您的案例中，由第一个
OnError
终止），将不再发出通知，这意味着不再调用代理。
允许0个或多个
OnNext
通知，然后是一个
OnCompleted
或一个
OnError
通知，从而终止可观察对象。一旦可观察对象被终止（在您的案例中，由第一个
OnError
终止），就不会再发出通知，这意味着不再调用代理。
哦，好的，但是如果管道中有一个错误（
OnNext
被调用），有没有办法不终止可观察对象。有一些操作符，如
Catch
和
Retry
，允许您对
OnError
作出反应并有效地重新连接。我建议阅读，特别是了解更多信息。允许多个错误的最干净的方法是从一个
IObservable
开始并执行以下操作：
source.Select（internal=>internal.Materialize（））.Merge（）
。然后你可以处理多个错误。哦，好的，但是如果管道中有一个错误（
OnNext
被调用），有没有办法不终止可观察的对象呢。有一些操作符，如
Catch
和
Retry
，允许您对
OnError
作出反应并有效地重新连接。我建议阅读，特别是了解更多信息。允许多个错误的最干净的方法是从一个
IObservable
开始并执行以下操作：
source.Select（internal=>internal.Materialize（））.Merge（）
。然后您可以处理多个错误。
public void OnError(Exception ex)
{
  Console.WriteLine(ex.Message);
 }