Esempio n. 1
0
 public IDisposable Run()
 {
     this.length = this.parent.sources.Length;
     this.queues = new Queue <T> [this.length];
     this.isDone = new bool[this.length];
     for (int i = 0; i < this.length; i++)
     {
         this.queues[i] = new Queue <T>();
     }
     IDisposable[] array = new IDisposable[this.length + 1];
     for (int j = 0; j < this.length; j++)
     {
         IObservable <T> observable = this.parent.sources[j];
         array[j] = observable.Subscribe(new ZipObservable <T> .Zip.ZipObserver(this, j));
     }
     array[this.length] = Disposable.Create(delegate
     {
         object obj = this.gate;
         lock (obj)
         {
             for (int k = 0; k < this.length; k++)
             {
                 Queue <T> queue = this.queues[k];
                 queue.Clear();
             }
         }
     });
     return(StableCompositeDisposable.CreateUnsafe(array));
 }
 public IDisposable Run()
 {
     this.length = this.sources.Count;
     if (this.length == 0)
     {
         this.OnNext(Unit.Default);
         try
         {
             this.observer.OnCompleted();
         }
         finally
         {
             base.Dispose();
         }
         return(Disposable.Empty);
     }
     this.completedCount = 0;
     IDisposable[] array = new IDisposable[this.length];
     for (int i = 0; i < this.length; i++)
     {
         IObservable <Unit> observable = this.sources[i];
         WhenAllObservable.WhenAll_.WhenAllCollectionObserver observer = new WhenAllObservable.WhenAll_.WhenAllCollectionObserver(this);
         array[i] = observable.Subscribe(observer);
     }
     return(StableCompositeDisposable.CreateUnsafe(array));
 }
Esempio n. 3
0
            public IDisposable Run()
            {
                length = sources.Length;

                // fail safe...
                if (length == 0)
                {
                    OnNext(new T[0]);

                    try { observer.OnCompleted(); }
                    finally { Dispose(); }

                    return(Disposable.Empty);
                }

                completedCount = 0;
                values         = new T[length];
                var subscriptions = new IDisposable[length];

                for (int index = 0; index < length; index++)
                {
                    var source   = sources[index];
                    var observer = new WhenAllCollectionObserver(this, index);
                    subscriptions[index] = source.Subscribe(observer);
                }

                return(StableCompositeDisposable.CreateUnsafe(subscriptions));
            }
 public IDisposable Run()
 {
     this.length      = this.parent.sources.Length;
     this.values      = new T[this.length];
     this.isStarted   = new bool[this.length];
     this.isCompleted = new bool[this.length];
     IDisposable[] array = new IDisposable[this.length];
     for (int i = 0; i < this.length; i++)
     {
         IObservable <T> observable = this.parent.sources[i];
         array[i] = observable.Subscribe(new ZipLatestObservable <T> .ZipLatest.ZipLatestObserver(this, i));
     }
     return(StableCompositeDisposable.CreateUnsafe(array));
 }