我可以使用无限范围并对其进行操作吗？

Question

Enumerable.Range(0, int.MaxValue)
          .Select(n => Math.Pow(n, 2))
          .Where(squared => squared % 2 != 0)
          .TakeWhile(squared => squared < 10000).Sum()

此代码会迭代从 0 到 max-range 的所有整数值，还是仅迭代整数值以满足 take-while、where 和 select 运算符？ 有人可以澄清一下吗？

编辑：我第一次尝试确保它按预期工作是愚蠢的。我撤销它:)

Answer 1

int.MaxValue + 5 溢出为负数。自己尝试一下：

unchecked
{
    int count = int.MaxValue + 5;
    Console.WriteLine(count); // Prints -2147483644
}

Enumerable.Range 的第二个参数必须是非负数 - 因此是例外。

不过，您当然可以在 LINQ 中使用无限序列。下面是这样一个序列的示例：

public IEnumerable<int> InfiniteCounter()
{
    int counter = 0;
    while (true)
    {
        unchecked
        {
            yield return counter;
            counter++;
        }
    }
}

当然，这也会溢出，但它会继续下去...

请注意，一些 LINQ 运算符（例如 Reverse）需要在产生第一个结果之前读取所有数据。其他人（例如Select）可以在从输入读取结果时保持流式传输结果。有关每个运算符的行为的详细信息（在 LINQ to Objects 中），请参阅我的 Edulinq 博客文章。

Answer 2

一般来说，解决此类问题的方法是逐步思考正在发生的事情。

Linq 将 linq 代码转换为由查询提供程序执行的代码。这可能是生成 SQL 代码之类的事情，或者各种各样的事情。对于 linq-to-objects，它会生成一些等效的 .NET 代码。思考 .NET 代码将是什么，让我们推断将会发生什么。*

通过您的代码，您可以得到：

Enumerable.Range(0, int.MaxValue)
                         .Select(n => Math.Pow(n, 2))
                         .Where(squared => squared % 2 != 0)
                         .TakeWhile(squared => squared < 10000).Sum()

Enumerable.Range 比：

for(int i = start; i != start + count; ++i)
  yield return i;

...但是对于争论来说已经足够接近了。

Select 足够接近：

foreach(T item in source)
  yield return func(item);

Where 足够接近：

foreach(T item in source)
  if(func(item))
    yield return item;

TakeWhile 足够接近：

foreach(T item in source)
  if(func(item))
    yield return item;
  else
    yield break;

Sum 足够接近：

T tmp = 0;//must be numeric type
foreach(T x in source)
  tmp += x;
return tmp;

这简化了一些优化等等，但足够接近推理。依次考虑这些，您的代码相当于：

double ret = 0; // part of equivalent of sum
for(int i = 0; i != int.MaxValue; ++i) // equivalent of Range
{
  double j = Math.Pow(i, 2);  // equivalent of Select(n => Math.Pow(n, 2))
  if(j % 2 != 0) //equivalent of Where(squared => squared %2 != 0)
  {
    if(j < 10000) //equivalent of TakeWhile(squared => squared < 10000)
    {
       ret += j; //equaivalent of Sum()
    }
    else //TakeWhile stopping further iteration
    {
      break;
    }
  }
}
return ret; //end of equivalent of Sum()

现在，在某些方面，上面的代码更简单，在某些方面，它更复杂。使用 LINQ 的全部意义在于，它在很多方面都更简单。不过，要回答您的问题“此代码是否会迭代从 0 到最大范围的所有整数值，或者只是遍历整数值以满足 take-while、where 和 select 运算符？”我们可以看上面，看到那些不满足where的会被迭代，发现不满足where，但是不再对它们做更多的工作，一旦TakeWhile满足了，所有进一步的工作已停止（我的非 LINQ 重写中的 break）。

当然，在这种情况下，只有 TakeWhile() 意味着调用将在合理的时间长度内返回，但我们还需要简要考虑其他调用，以确保它们在运行时产生。考虑代码的以下变体：

Enumerable.Range(0, int.MaxValue)
  .Select(n => Math.Pow(n, 2))
  .Where(squared => squared % 2 != 0)
  .ToList()
  .TakeWhile(squared => squared < 10000).Sum()

理论上，这将给出完全相同的答案，但需要更长的时间和更多的内存来执行此操作（可能足以导致内存不足异常）。这里等效的非 linq 代码是：

List<double> tmpList = new List<double>(); // part of ToList equivalent
for(int i = 0; i != int.MaxValue; ++i) // equivalent of Range
{
  double j = Math.Pow(i, 2);  // equivalent of Select(n => Math.Pow(n, 2))
  if(j % 2 != 0) //equivalent of Where(squared => squared %2 != 0)
  {
    tmpList.Add(j);//part of equivalent to ToList()
  }
}
double ret = 0; // part of equivalent of sum
foreach(double k in tmpList)
{
  if(k < 10000) //equivalent of TakeWhile(squared => squared < 10000)
  {
     ret += k; //equaivalent of Sum()
  }
  else //TakeWhile stopping further iteration
  {
    break;
  }
}
return ret; //end of equivalent of Sum()

这里我们可以看到将 ToList() 添加到 Linq 查询如何极大地影响查询，以便由 Range() 生成的每个项目> 必须处理呼叫。像 ToList() 和 ToArray() 这样的方法会打破链接，以便非 linq 等价物不再适合彼此“内部”，因此没有人可以停止这些方法的操作之前的。 （Sum() 是另一个示例，但由于它位于示例中的 TakeWhile() 之后，因此这不是问题）。

使它经历范围的每次迭代的另一件事是如果您有 While(x => false) ，因为它永远不会在 TakeWhile 中实际执行测试。

*尽管可能有进一步的优化，特别是在 SQL 代码的情况下，而且在概念上，例如 Count() 相当于：

int c = 0;
foreach(item in src)
  ++c;
return c;

这将被转换为对 Count 的调用ICollection 的 code> 属性或数组的 Length 属性意味着上面的 O(n) 被 O(1)（对于大多数 ICollection 实现）调用替换，这对于大型序列。

Answer 3

仅当满足 TakeWhile 条件时，您的第一个代码才会迭代。在 int.MaxValue 之前它不会进行迭代。

int.MaxValue + 5 将得到负整数。如果第二个参数为负数，Enumerable.Range 会抛出 ArgumentOutOfRangeException。这就是为什么你会得到异常（在任何迭代发生之前）。