关于 Enumerable.Range 与传统 for 循环的 foreach 的思考
Posted
技术标签:
【中文标题】关于 Enumerable.Range 与传统 for 循环的 foreach 的思考【英文标题】:Thoughts on foreach with Enumerable.Range vs traditional for loop 【发布时间】:2010-10-29 06:45:07 【问题描述】:在 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”很小,所以性能不是问题,有人反对新风格而不是传统风格吗?
【问题讨论】:
现在这个问题,包括来自许多答案的总结,真的很相关,几乎是 SO 中问题的良好实践模型。应该装框! @heltonbiker 错误——实际上包含摘要不适合 SO 模型。应删除摘要。 SO 作为问答网站将问题和答案分开,而不是有一个“帖子”的一般概念。 两者的行为会有所不同,具体取决于您正在编译的 .Net 版本。 for 循环版本可能并不总是保留执行上下文,特别是如果您有一个 yield 语句。 使用 Range() 还有一个好处:你可以在循环内改变 index 的值,而且不会破坏你的循环。 期待在此线程中添加新的 C# 8.0 功能! docs.microsoft.com/en-us/dotnet/csharp/whats-new/… 【参考方案1】:只是把我的帽子扔进戒指。
我定义这个...
namespace CustomRanges
public record IntRange(int From, int Thru, int step = 1) : IEnumerable<int>
public IEnumerator<int> GetEnumerator()
for (var i = From; i <= Thru; i += step)
yield return i;
IEnumerator IEnumerable.GetEnumerator()
=> GetEnumerator();
;
public static class Definitions
public static IntRange FromTo(int from, int to, int step = 1)
=> new IntRange(from, to - 1, step);
public static IntRange FromThru(int from, int thru, int step = 1)
=> new IntRange(from, thru, step);
public static IntRange CountFrom(int from, int count)
=> new IntRange(from, from + count - 1);
public static IntRange Count(int count)
=> new IntRange(0, count);
// Add more to suit your needs. For instance, you could add in reversing ranges, etc.
然后在我想使用它的任何地方,我将它添加到文件的顶部...
using static CustomRanges.Definitions;
然后像这样使用它......
foreach(var index in FromTo(1, 4))
Debug.WriteLine(index);
// Prints 1, 2, 3
foreach(var index in FromThru(1, 4))
Debug.WriteLine(index);
// Prints 1, 2, 3, 4
foreach(var index in FromThru(2, 10, 2))
Debug.WriteLine(index);
// Prints 2, 4, 6, 8, 10
foreach(var index in CountFrom(7, 4))
Debug.WriteLine(index);
// Prints 7, 8, 9, 10
foreach(var index in Count(5))
Debug.WriteLine(index);
// Prints 0, 1, 2, 3, 4
foreach(var _ in Count(4))
Debug.WriteLine("A");
// Prints A, A, A, A
这种方法的好处在于名称,您可以确切地知道是否包含结尾。
【讨论】:
【参考方案2】:今天如何使用新语法
由于这个问题,我尝试了一些方法来提出一个好的语法,而无需等待一流的语言支持。这是我所拥有的:
using static Enumerizer;
// prints: 0 1 2 3 4 5 6 7 8 9
foreach (int i in 0 <= i < 10)
Console.Write(i + " ");
不是<=
和<
之间的区别。
我还创建了一个proof of concept repository on 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();
【讨论】:
【参考方案3】:对于已经解决的问题,这似乎是一种冗长的方法。 Enumerable.Range
后面有一个不需要的完整状态机。
传统格式是开发的基础,并且为所有人所熟悉。我真的看不出你的新风格有什么好处。
【讨论】:
在某些方面。当您想从最小值迭代到最大值时,Enumerable.Range 变得同样不可读,因为第二个参数是一个范围,需要计算。 啊,好点,但那是另一种情况(我还没有遇到过)。在这种情况下,也许使用 (start, end) 而不是 (start, count) 的扩展方法会有所帮助。【参考方案4】:在我看来,Enumerable.Range()
方式更具声明性。对人们来说是新的和不熟悉的?当然。但我认为这种声明性方法与大多数其他与 LINQ 相关的语言功能具有相同的好处。
【讨论】:
【参考方案5】:我同意在许多(甚至大多数情况下)foreach
在简单地迭代集合时比标准的for
-loop 更具可读性。但是,您选择使用 Enumerable.Range(index, count)
并不是 foreach
价值超过 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);
【讨论】:
我同意 - 类似于 Spender 关于从最小值迭代到最大值的评论。【参考方案6】:我确实喜欢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
! ;-)
【讨论】:
嘿,我想知道我什么时候会被那个 :) 我更新了我的示例,以免影响主要问题。【参考方案7】:@卢克:
我重新实现了您的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();
【讨论】:
我认为 .Reverse() 最终会在读取第一项时将整个集合加载到内存中。 (除非 Reverse 检查迭代器的底层类型并说“啊,这是一个 Enumerator.Range 对象。我将发出一个向后计数的对象,而不是我的正常行为。”)【参考方案8】:我想要一些其他语言的语法,例如 Python、Haskell 等。
// Write the numbers 1 thru 7
foreach (int index in [1..7])
Console.WriteLine(index);
幸运的是,我们现在得到了 F# :)
至于 C#,我将不得不坚持使用 Enumerable.Range
方法。
【讨论】:
C# 中有一段时间了 docs.microsoft.com/en-us/dotnet/csharp/language-reference/…【参考方案9】:我有点喜欢这个主意。它非常像 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 ]
【讨论】:
那么 Python 范围是否像 C++ STL 和 D 范围一样是完全排他的?我喜欢。作为一个初学者,我曾经喜欢 first..last(end-inclusive),直到使用更复杂的嵌套循环和图像,最终通过消除所有那些脏的 +1 和 -1 来意识到 end-exclusive(begin end)是多么优雅代码。不过,在普通英语中,“to”往往意味着包容,因此将参数命名为“start”/“end”可能比“from”/“to”更清晰。!(step > 0 ^ from < to)
可以重写为step > 0 == from < to
。或者更简洁:使用带有 endcondition from += step != to
的 do-while 循环【参考方案10】:
在 C# 6.0 中使用
using static System.Linq.Enumerable;
你可以把它简化为
foreach (var index in Range(1, 7))
Console.WriteLine(index);
【讨论】:
我认为 7 是计数:public static IEnumerableusing static
是什么。应该提到写起来更具可读性:Enumerable.Range(1, 7).ToList().ForEach(Console.WriteLine);
【参考方案11】:
我认为 Range 对于使用一些内联范围很有用:
var squares = Enumerable.Range(1, 7).Select(i => i * i);
你们都可以过来。需要转换为列表,但在需要时保持紧凑。
Enumerable.Range(1, 7).ToList().ForEach(i => Console.WriteLine(i));
但除了这样的事情,我会使用传统的 for 循环。
【讨论】:
例如,我只是在我的代码中这样做,为sqlvar paramList = String.Join(",", Enumerable.Range(0, values.Length).Select(i => "@myparam" + i));
建立一组动态参数
Enumerable.Range(1, 7).ToList().ForEach(Console.WriteLine);
更好【参考方案12】:
您实际上可以在 C# 中执行此操作(通过分别在 int
和 IEnumerable<T>
上提供 To
和 Do
作为扩展方法):
1.To(7).Do(Console.WriteLine);
SmallTalk 永远!
【讨论】:
很好 - 我假设您只需为“To”和“Do”创建几个扩展方法? 我认为 C++ 语法不好 LOL 嗯... To and Do 对我不起作用?这是哪个图书馆的一部分?我在 .Net 4.0 上。 @BlueVoodoo 它们是您需要定义的扩展方法。 我不喜欢Do
扩展方法。如果它像其他人建议的那样进入foreach
循环,那就更清楚了。【参考方案13】:
严格来说,你滥用了枚举。
枚举器提供了逐一访问容器中所有对象的方法,但它不保证顺序。
可以使用枚举来查找数组中的最大数。如果您使用它来查找第一个非零元素,那么您将依赖于您不应该知道的实现细节。在您的示例中,顺序似乎对您很重要。
编辑:我错了。正如 Luke 指出的(参见 cmets),在 C# 中枚举数组时依赖顺序是安全的。这与例如在 javascript 中使用“for in”枚举数组不同。
【讨论】:
不确定 - 我的意思是,Range 方法被构建为返回一个递增序列,所以我不确定我是如何依赖实现细节的。你(或其他任何人)能详细说明吗? 我不认为返回的序列是递增的。当然,它总是在实践中。您可以枚举任何集合。对许多人来说,有很多订单是有意义的,你可能会得到其中任何一个。 @Marcel, @buti-oxa:枚举过程(例如,使用 foreach)本身并不保证任何特定的排序,但排序由决定使用的枚举器:Array、List 等的内置枚举器将始终按元素顺序迭代;对于 SortedDictionary、SortedList 等,它将始终以键比较顺序进行迭代;对于 Dictionary、HashSet 等,没有保证顺序。我非常有信心您可以依赖 Enumerable.Range 始终按升序迭代。 当然,枚举器知道它提供的顺序,所以如果我写枚举器,我可以依赖顺序。如果编译器/库对我有用,我怎么知道。它是否在规范/文档中的某处说数组的内置枚举器总是从 1 迭代到 N?我找不到这个承诺。 @buti-oxa,查看 C#3 规范的第 8.8.4 节(第 240 页):“对于单维数组,元素以递增的索引顺序遍历,从索引 0 开始并以索引长度 - 1 结尾。” (download.microsoft.com/download/3/8/8/…)【参考方案14】:这只是为了好玩。 (我自己会使用标准的“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);
【讨论】:
public static IEnumerableStep
方法工作正常:i
是索引,而不是值。你是对的,性能不是很好,但这是一个概念验证演示,而不是生产代码。【参考方案15】:
我认为 foreach + Enumerable.Range 不太容易出错(您的控制权和出错的方法更少,比如减少主体内的索引,这样循环就永远不会结束,等等)
可读性问题与 Range 函数语义有关,它可以从一种语言更改为另一种语言(例如,如果只给定一个参数,它将从 0 或 1 开始,或者包含或排除结尾,或者第二个参数是计数而是一个最终值)。
关于性能,我认为编译器应该足够聪明,可以优化两个循环,以便它们以相似的速度执行,即使范围很大(我认为 Range 不会创建集合,但当然是迭代器)。
【讨论】:
【参考方案16】:为此,我发现后者的“最小到最大”格式比Range
的“最小计数”样式要清晰得多。另外,我认为从不更快、不更短、不更熟悉、不明显更清晰的规范进行这样的改变并不是一个好习惯。
也就是说,总的来说,我并不反对这个想法。如果您向我提出类似于foreach (int x from 1 to 8)
的语法,那么我可能会同意这将是对for
循环的改进。但是,Enumerable.Range
相当笨拙。
【讨论】:
使用 C# 4 的命名参数功能,我们可以添加一个扩展方法并像这样调用它(我现在没有一个好名字): foreach (int x in Enumerable.Range2( from = 1, to = 8)) 好还是坏 ;) 对不起,这是“(从:1,到:8)” 就我个人而言,这对我来说太冗长和笨拙了(与 for 循环相反),但我知道这在某种程度上是一个品味问题。 @mquander 这看起来很像 VB 的语法:For i = 1 To 8
从 Scala 窃取foreach(var x in (1 to 8))
怎么样?它是一个 Enumerable 类型。【参考方案17】:
我想在处理参数表达式时,Enumerable.Range(index, count)
可能会更清晰,特别是如果该表达式中的某些值在循环内被更改。在 for
的情况下,表达式将根据当前迭代后的状态进行评估,而 Enumerable.Range()
是预先评估的。
除此之外,我同意坚持使用for
通常会更好(对更多人来说更熟悉/更易读......可读性是需要维护的代码中一个非常重要的值)。
【讨论】:
【参考方案18】:我相信每个人都有自己的个人喜好(很多人更喜欢后者,因为它比几乎所有编程语言都熟悉),但我和你一样,开始越来越喜欢 foreach,尤其是现在你可以定义一个范围。
【讨论】:
以上是关于关于 Enumerable.Range 与传统 for 循环的 foreach 的思考的主要内容,如果未能解决你的问题,请参考以下文章
为啥 Enumerable.Range 比直接 yield 循环快?
从 Enumerable.Range 或 List<int> 填充 List<dynamic>
csharp 对于那些需要在一段时间内创建DropDownList的时候,您可以通过“Enumerable.Range”轻松完成。样本c