C# RX-Zip输出意外的结果

请帮助我了解一个现象：

为什么X不等于可观察项的索引？

       // (1) Create From Collection .
       IObservable<EcgSample> sampleObservable = CreateSamples().ToObservable(new EventLoopScheduler());

       // (2) Repeat 
       IObservable<EcgSample> repeated = sampleObservable.Repeat();

       // (3) Indexed 
       IObservable<Tuple<EcgSample,int>> indexed = repeated.Select((item, index) =>
       {
           item.X = index;
           return new Tuple<EcgSample, int>(item, index);
       }); 

       // (4) Buffered 
       IObservable<IList<Tuple<EcgSample, int>>> buffered = indexed.Buffer(250); 

       // (5) SelectMany and Print .
       _disposable = buffered.SelectMany(buf => buf).Subscribe(Print);

构建块，例如：

        public class EcgSample
        {               
            public EcgSample(int y)
            {
                Y = y;   
            } 

            public int X { get; set; }
            public int Y { get; set; }  
        }

        private void Print(Tuple<EcgSample, int> s)
        {
              Debug.WriteLine("X : {0} , Y : {1} , Index : {2}", s.Item1.X, s.Item1.Y, s.Item2);
        }

        private List<EcgSample> CreateSamples()
        {
            var testSamples = new List<EcgSample>();

            for (short i = 0; i < 1400; i++)
            {
               testSamples.Add(new EcgSample(i));   
            }

            return testSamples;
        }

修改：（不输出非预期结果）

现在，我不希望每个间隔都使用每个缓冲区：

     // (5) Create an Observable from a Timer. 
     IObservable<ElapsedEventArgs> timerObservable = Observable.Create<ElapsedEventArgs>(
            observer =>
            {
                var timer = new Timer();
                timer.Interval = 250;
                timer.Elapsed += (s, e) => observer.OnNext(e);
                timer.Start();
                return Disposable.Create(() =>
                {
                    timer.Stop();
                });
            });

        // (6) Zip with the buffer observable 
        IObservable<IList<Tuple<EcgSample, int>>> zipped = timerObservable.Zip(buffered, (t, b) => b);

        // (7) SelectMany and Print .
        _disposable = zipped.SelectMany(buf => buf).Subscribe(Print);

你知道为什么X从187600开始吗（不用说每次运行我的程序时这个值都不一样）

编辑：

我通过在最后简单地投影解决了这个问题，但我仍然想知道为什么会出现第一个问题

        List<EcgSample> list = CreateSamples();     

        var loop = new EventLoopScheduler();
        var sampleObservable = list.ToObservable(loop);

        IObservable<EcgSample> reapeted = sampleObservable.Repeat();

        IObservable<IList<EcgSample>> buffered = reapeted.Buffer(250);

        IObservable<ElapsedEventArgs> timerObservable = Observable.Create<ElapsedEventArgs>(
            observer =>
            {
                var timer = new Timer();
                timer.Interval = 250;
                timer.Elapsed += (s, e) => observer.OnNext(e);
                timer.Start();
                return Disposable.Create(() =>
                {
                    timer.Stop();
                });
            });

        IObservable<IList<EcgSample>> zipped = timerObservable.Zip(buffered, (t, b) => b);

        _disposable = zipped.SelectMany(buf => buf).Select((item, index) =>
        {
            item.X = index;
            return new Tuple<EcgSample, int>(item, index);

        }).Subscribe(Print);

List List=CreateSamples（）；
var loop=新的EventLoopScheduler（）；
var sampleObservable=list.ToObservable（循环）；
IObservable Reapedd=样本可观察。重复（）；
IObservable buffered=重新分配的缓冲区（250）；
IObservable timerObservable=可观测。创建(
观察员=>
{
var timer=new timer（）；
时间间隔=250；
timer.appead+=（s，e）=>observer.OnNext（e）；
timer.Start（）；
返回一次性。创建（（）=>
{
timer.Stop（）；
});
});
IObservable zipped=timerObservable.Zip（缓冲，（t，b）=>b）；
_一次性=压缩。选择多个（buf=>buf）。选择（（项目，索引）=>
{
项目X=索引；
返回新元组（项、索引）；
}).订阅（打印）；

你的答案只显示了一件事，你可以改变它来获得你想要的行为，但这并不是它没有按你期望的方式工作的真正原因

如果您想将可观察对象中的每个条目与一个数字相关联，那么实际上应该将其与一个数字相关联。按照您的方式，流中的每个元素与数字之间没有实际的联系。您的修复只是确保在下一个项目通过之前处理每个项目，因此该数字恰好处于正确的值。但这是一个非常脆弱的局面

如果您只想了解流中的项目的运行计数，请查看：

或者，如果您想要与流中的项目计数不同的内容，您可以执行以下操作：

stream.Select(item => new { item, index = <some value you calculate> })
...

您可以在LinqPad中运行该代码，这是一个非常有用的工具，用于探索Rx（以及.Net的其他部分）

最后，我假设这是一个简单的练习，试图找出在你的情况下发生了什么。看起来您可能正在尝试处理传感器数据，这些数据推送的更新比您想要处理的要多。间隔使用Zip不会有多大帮助。您将减慢数据的到达速度，但它只会建立一个越来越大的数据队列，等待通过Zip

---

如果希望每250毫秒获取一个数据点，请查看。如果您想一次获得250毫秒的读数，请查看。

是的，您的权利，我想更新我的问题。因为在玩了这一点之后，即使是我的解决方案，情况还是回来了。此外，我不想劫持线程，而是让系统处理线程问题。

        List<EcgSample> list = CreateSamples();     

        var loop = new EventLoopScheduler();
        var sampleObservable = list.ToObservable(loop);

        IObservable<EcgSample> reapeted = sampleObservable.Repeat();

        IObservable<IList<EcgSample>> buffered = reapeted.Buffer(250);

        IObservable<ElapsedEventArgs> timerObservable = Observable.Create<ElapsedEventArgs>(
            observer =>
            {
                var timer = new Timer();
                timer.Interval = 250;
                timer.Elapsed += (s, e) => observer.OnNext(e);
                timer.Start();
                return Disposable.Create(() =>
                {
                    timer.Stop();
                });
            });

        IObservable<IList<EcgSample>> zipped = timerObservable.Zip(buffered, (t, b) => b);

        _disposable = zipped.SelectMany(buf => buf).Select((item, index) =>
        {
            item.X = index;
            return new Tuple<EcgSample, int>(item, index);

        }).Subscribe(Print);

stream.Select((item, index) => new { item, index })
      .Subscribe(data => Debug.WriteLine("Item at index {0} is {1}", data.index, data.item))

stream.Select(item => new { item, index = <some value you calculate> })
...

var items = Enumerable.Range(65, 26)
                      .Select(i => (char)i)
                      .Repeat();

var observableItems = items.ToObservable()
                           .Select((c, i) => new { Char = c, Index = i });

var interval = Observable.Interval(TimeSpan.FromSeconds(0.25));

var buffered = observableItems.Buffer(10);
var zipped = buffered.Zip(interval, (buffer, _) => buffer);

zipped.SelectMany(buffer => buffer).Dump();