C# - TakeWhile 和 SkipWhile 不返回？

Question

我有一个类 RekenReeks，它返回从 2 开始的数字，乘以 2。所以 {2,4,8,16,32,64}

现在我了解了 TakeWhile 和 SkipWhile 方法以及 LINQ。

所以我创建了 3 个变量，它们应该存储完全相同，但我的 Console.WriteLine 只打印 selection1 而不是 2 和 3。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            RekenReeks reeks = new RekenReeks(2, n => n * 2);
            var selection = from i in reeks
                        where i > 10
                        && i < 1000
                        select i;

        var selection2 = reeks.TakeWhile(n => n < 1000 && n > 10);

        var selection3 = reeks.SkipWhile(n => n > 1000 && n < 10);

        foreach (int i in selection)
        {
            Console.WriteLine("selection1 {0}",i);
        }

        foreach (int i in selection2)
        {
            Console.WriteLine("selection2 {0}", i);
        }

        foreach (int i in selection3)
        {
            Console.WriteLine("selection3 {0}", i);
        }

        Console.ReadLine();
    }
}


public class RekenReeks : IEnumerable<int>
{
    Func<int, int> getNew;
    int number;
    public RekenReeks(int starton, Func<int, int> getNewThing)
    {
        getNew = getNewThing;
        number = starton;
    }

    public IEnumerator<int> GetEnumerator()
    {
        yield return number;
        for (; ; )
        {

            yield return getNew(number);
            number = getNew(number);

        }

    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }


}
}

Answer 1

您的序列是无限的（理论上）。你假设太多了。您的程序的功能不可能知道您的序列是严格单调递增的。

var selection = from i in reeks
                    where i > 10
                    && i < 1000
                    select i;

这永远不会停止。因为where总是拉下一个值，它不知道它的条件会被满足，它总是有去检查下一个值。

    var selection2 = reeks.TakeWhile(n => n < 1000 && n > 10);

这将采用介于 11 和 999 之间的值。由于您的序列从 2 开始，它将在第一个值处停止。

    var selection3 = reeks.SkipWhile(n => n > 1000 && n < 10);

这将跳过介于 11 和 999 之间的值。由于第一个是 2，它将不跳过任何值，因此产生 all。

Answer 2

TakeWhile() 和 SkipWhile() 都从序列的最开头开始，当条件不满足时停止获取/跳过。

  // I've redesigned your ReekenReeks
  // [2, 4, 8, 16, 32, 64, ..., 2**30]
  var reeks = Enumerable
    .Range(1, 30)
    .Select(index => 1 << index);

例如，如果你把

  var selection2 = reeks
    .TakeWhile(n => n < 1000 && n > 10);

由于reeks 的第一项是2，条件n < 1000 && n > 10 不满足TakeWhile 停止并返回一个空 序列。正确的实现是

  var selection2 = reeks
    .SkipWhile(n => n <= 10)
    .TakeWhile(n => n < 1000);

如果你想从序列（selection3）的中间截断值，你必须使用Where：

  var selection3 = reeks
    .Where(n => !(n > 1000 && n < 10)); // cut theses items off

打印出 infinine 序列时要小心，.Take() 在这里是个不错的选择：

   var selection3 = reeks
    .Where(n => n > 1000 && n < 10)
    .Take(100); // First 100 items in case the sequence is too long

Answer 3

var selection = from i in reeks
  where i > 10
  && i < 1000
  select i;

没有理由让这一切结束。当i 为1024 时，它不会产生，但它仍会检查2048 是否小于1000，或4096 小于1000，或8192 是否小于@987654328 @ 以此类推（最终要么发生溢出异常，要么n 环绕到0，然后一直设置为0 * 2，仍然是0）。

reeks.TakeWhile(n => n < 1000 && n > 10)

第一个尝试的值是2。这不满足谓词n < 1000 && n > 10，因为2 > 10 不是真的。因此，采取停止。

reeks.SkipWhile(n => n > 1000 && n < 10)

n 没有对应的 n > 1000 && n < 10 值。因此，这与根本没有SkipWhile 相同。

看来你想要的是：

reeks.SkipWhile(n => n >= 1000 || n <= 10).TakeWhile(n => n < 1000 && n > 10)

它会跳过，直到找到第一个符合条件的数字，然后取所有符合条件的数字，直到第一个不符合条件的数字。