在C＃3.0中，我喜欢这种样式：

// Write the numbers 1 thru 7
foreach (int index in Enumerable.Range( 1, 7 ))
{
    Console.WriteLine(index);
}

在传统for循环中：

// Write the numbers 1 thru 7
for (int index = 1; index <= 7; index++)
{
    Console.WriteLine( index );
}

假设“ n”很小，那么性能就不成问题了，有人反对传统风格吗？

我发现后者的“最小到最大”格式比Range“最小计数”样式更清晰。此外，我认为从规范中进行这样的更改（不是更快，更短，更不熟悉，也不很明显）并不是真正的好习惯。

也就是说，我总体上并不反对这个想法。如果您提出的语法看起来像是foreach (int x from 1 to 8)我，那么我可能会同意这将是对for循环的改进。但是，Enumerable.Range是很笨重的。

这只是为了好玩。（我自己会使用标准的“ for (int i = 1; i <= 10; i++)”循环格式。）

foreach (int i in 1.To(10))
{
    Console.WriteLine(i);    // 1,2,3,4,5,6,7,8,9,10
}

// ...

public static IEnumerable<int> To(this int from, int to)
{
    if (from < to)
    {
        while (from <= to)
        {
            yield return from++;
        }
    }
    else
    {
        while (from >= to)
        {
            yield return from--;
        }
    }
}

您也可以添加Step扩展方法：

foreach (int i in 5.To(-9).Step(2))
{
    Console.WriteLine(i);    // 5,3,1,-1,-3,-5,-7,-9
}

// ...

public static IEnumerable<T> Step<T>(this IEnumerable<T> source, int step)
{
    if (step == 0)
    {
        throw new ArgumentOutOfRangeException("step", "Param cannot be zero.");
    }

    return source.Where((x, i) => (i % step) == 0);
}

在C＃6.0中配合使用

using static System.Linq.Enumerable;

您可以简化为

foreach (var index in Range(1, 7))
{
    Console.WriteLine(index);
}

您实际上可以在C＃中执行此操作（分别在和上提供To和Do作为扩展方法）：intIEnumerable<T>

1.To(7).Do(Console.WriteLine);

永远的SmallTalk！

我有点喜欢这个主意。这非常像Python。以下是我的版本：

static class Extensions
{
    public static IEnumerable<int> To(this int from, int to, int step = 1) {
        if (step == 0)
            throw new ArgumentOutOfRangeException("step", "step cannot be zero");
        // stop if next `step` reaches or oversteps `to`, in either +/- direction
        while (!(step > 0 ^ from < to) && from != to) {
            yield return from;
            from += step;
        }
    }
}

它的工作方式类似于Python：

• 0.To(4) → [ 0, 1, 2, 3 ]
• 4.To(0) → [ 4, 3, 2, 1 ]
• 4.To(4) → [ ]
• 7.To(-3, -3) → [ 7, 4, 1, -2 ]

我认为foreach + Enumerable.Range不太容易出错（您的控制较少，错误处理的方式也较少，例如减少体内的索引，使循环永远不会结束，等等）。

可读性问题与范围函数语义有关，它可以从一种语言更改为另一种语言（例如，如果仅给出一个参数，它将从0或1开始，或者是包含或排除的结尾，还是第二个参数是计数而不是结尾）值）。

关于性能，我认为编译器应该足够聪明来优化两个循环，以便即使在较大范围内，它们也能以相似的速度执行（我想Range不会创建集合，而是创建迭代器）。

对于已经解决的问题，似乎采用了漫长的方法。背后有整个状态机Enumerable.Range真正不需要。

传统格式是开发的基础，也是所有人都熟悉的格式。我真的看不到您的新样式有任何优势。

我认为Range对于使用某些范围内联很有用：

var squares = Enumerable.Range(1, 7).Select(i => i * i);

你们都可以结束。需要转换为列表，但在需要时保持紧凑。

Enumerable.Range(1, 7).ToList().ForEach(i => Console.WriteLine(i));

但是除了类似这样的事情，我会使用传统的for循环。

我想要其他一些语言的语法，例如Python，Haskell等。

// Write the numbers 1 thru 7
foreach (int index in [1..7])
{
    Console.WriteLine(index);
}

幸运的是，我们现在有了F＃:)

至于C＃，我必须坚持使用该Enumerable.Range方法。

@Luke：我重新实现了To()扩展方法，并使用该Enumerable.Range()方法进行了扩展。这样，它就会变得更短一些，并使用.NET给我们的尽可能多的基础架构：

public static IEnumerable<int> To(this int from, int to)
{ 
    return from < to 
            ? Enumerable.Range(from, to - from + 1) 
            : Enumerable.Range(to, from - to + 1).Reverse();
}

我确定每个人都有自己的个人喜好（许多人更喜欢后者，因为它对几乎所有编程语言都很熟悉），但是我就像您一样，开始越来越喜欢foreach，尤其是现在您可以定义范围了。

我认为这种Enumerable.Range()方式更具说明性。陌生的人？当然。但是我认为这种声明性方法产生的好处与大多数其他与LINQ相关的语言功能相同。

今天如何使用新语法

由于这个问题，我尝试了一些方法，以提供一种不错的语法，而无需等待一流的语言支持。这是我所拥有的：

using static Enumerizer;

// prints: 0 1 2 3 4 5 6 7 8 9
foreach (int i in 0 <= i < 10)
    Console.Write(i + " ");

<=和之间没有区别<。

我还在GitHub上 创建了概念证明存储库，它具有更多功能（反向迭代，自定义步长）。

上述循环的最小且非常有限的实现如下所示：

public readonly struct Enumerizer
{
    public static readonly Enumerizer i = default;

    public Enumerizer(int start) =>
        Start = start;

    public readonly int Start;

    public static Enumerizer operator <(int start, Enumerizer _) =>
        new Enumerizer(start);

    public static Enumerizer operator >(int _, Enumerizer __) =>
        throw new NotImplementedException();

    public static IEnumerable<int> operator <=(Enumerizer start, int end)
    {
        for (int i = start.Start; i < end; i++)
            yield return i;
    }

    public static IEnumerable<int> operator >=(Enumerizer _, int __) =>
        throw new NotImplementedException();
}

我想象Enumerable.Range(index, count)在处理参数的表达式时，可能会有更清晰的场景，尤其是如果该表达式中的某些值在循环内被更改时。在for表达式的情况下，将基于当前迭代后的状态来评估，而Enumerable.Range()。

除此之外，我同意坚持for通常会更好（对更多的人更熟悉/更易读……可读性是需要维护的代码中非常重要的价值）。

我同意，在很多情况下（甚至大多数情况下），仅对集合进行迭代时，其foreach可读性就比标准for循环好得多。但是，您选择使用Enumerable.Range(index, count)并不是价值的有力例证。foreachover for。

对于一个简单的范围，从1, Enumerable.Range(index, count)看起来很可读。但是，如果范围以不同的索引开头，则它的可读性会降低，因为您必须正确执行index + count - 1以确定最后一个元素将是什么。例如…

// Write the numbers 2 thru 8
foreach (var index in Enumerable.Range( 2, 7 ))
{
    Console.WriteLine(index);
}

在这种情况下，我更喜欢第二个示例。

// Write the numbers 2 thru 8
for (int index = 2; index <= 8; index++)
{
    Console.WriteLine(index);
}

严格来说，您滥用枚举。

枚举器提供了一种访问容器中所有对象的方法，但是不能保证顺序。

可以使用枚举查找数组中的最大数字。如果要使用它来查找第一个非零元素，那么您将依赖您不应该知道的实现细节。在您的示例中，顺序似乎对您很重要。

编辑：我错了。正如Luke指出的那样（请参见注释），在C＃中枚举数组时可以依赖顺序。这与例如使用“ for in”枚举Javascript中的数组不同。

我喜欢foreach+Enumerable.Range方法，有时会使用它。

// does anyone object to the new style over the traditional style?
foreach (var index in Enumerable.Range(1, 7))

我反对var你提议中的滥用。非常感谢var，但是，该死，int在这种情况下，请写信！;-)