CodeGo.net>是否有一个简短的版本的for循环到任何东西x次?

通常,我们使用计数器执行诸如for或while循环的操作:

for (int i = 0; i < 10; i++)
{
    list.Add(GetRandomItem());
}

但有时您会混入界限。 您可以改用while循环,但是如果您犯了一个错误,则该循环是无限的...

例如在Perl中,我会使用更明显的

for(1..10){
    list->add(getRandomItem());
}

是否有类似“ doitXtimes(10){...}”的内容?

mbx asked 2020-01-24T01:36:50Z
7个解决方案
61 votes

好了,您可以轻松编写自己的扩展方法:

public static void Times(this int count, Action action)
{
    for (int i = 0; i < count; i++)
    {
        action();
    }
}

然后您可以编写:

10.Times(() => list.Add(GetRandomItem()));

我不确定我是否会建议您这样做,但这是一个选择。 我不相信框架中会发生类似的事情,尽管您可以使用using static或271609915999151818209创建适当长度的延迟序列,这在某些情况下很有用。


从C#6开始,您仍然可以使用using static指令导入静态方法来方便地访问静态方法而无需创建扩展方法。 例如:

// Normally in a namespace, of course.
public class LoopUtilities
{
    public static void Repeat(int count, Action action)
    {
        for (int i = 0; i < count; i++)
        {
            action();
        }
    }
}

然后,当您要使用它时:

using static LoopUtilities;

// Class declaration etc, then:
Repeat(5, () => Console.WriteLine("Hello."));
Jon Skeet answered 2020-01-24T01:37:28Z
41 votes
foreach (var i in Enumerable.Range(0, N))
{
    // do something
}
Grozz answered 2020-01-24T01:37:44Z
34 votes

一个可以创建一个IEnumerable的Int32:

Enumerable.Range(0, 10);

ForEach扩展方法也是众所周知的(尽管.NET并未提供)。 您可以将两者结合起来:

Enumerable.Range(0, 10).ForEach(index => ...);

因此,您的示例将变为:

Enumerable.Range(0, 10).ForEach(_ => list.Add(GetRandomItem()));
Paul Ruane answered 2020-01-24T01:38:12Z
12 votes

我看到乔恩·斯凯特(Jon Skeet)击败了我,但是这种变化将使您可以在每次运行时将索引传递给Action:

public static class IntegerExtensions
{
  public static void TimesWithIndex(this int count, Action<int> action)
  {
     for (int i = 0; i < count; i++)
        action(i);
  }
}

并这样称呼它:

10.TimesWithIndex((i) =>
            obj[i].DoSomething());
Alex Baranosky answered 2020-01-24T01:38:37Z
4 votes

仍然缺少一种方法:

List<T> list = System.Linq.Enumerable.Range(0, 10).Select(_ => GetRandomItem()).ToList();

其中T是GetRandomItem()返回的类型

A. Morel answered 2020-01-24T01:39:01Z
3 votes

例子1

            var loop = new Loop(50);
            foreach(var index loop) {
                // do something
            }

例子2

            foreach(var index in 50.Times().Start(1).Step(-1)) {
                // do something
            }

例子3

            var loop = 20.Times();
            while (loop.Do) {
                // do something
            }

循环类和扩展

public class Loop : IEnumerable<int> {

    readonly int times = 0;
    int start = 0;
    int step = 1;
    IEnumerator<int> e;

    public Loop (int times, int start = 0, int step = 1) {
        this.times = times < 0? 0-times : times;
        this.start = start;
        this.step = step;
    }

    public Loop Start(int value) {
        this.start = value;
        return this;
    }

    public Loop Step(int value) {
        this.step = value;
        return this;
    }

    public bool Do {
        get {
            if (this.e.IsNull()) {
                this.e = this.GetEnumerator();
            }
            if (this.e.MoveNext()) {
                return true;
            }
            else {
                this.e.Dispose();
                this.e = null;
                return false;
            }
        }
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return this.GetEnumerator();
    }
    public IEnumerator<int> GetEnumerator() {
        int count = times;
        int value = start;
        while (count != 0) {
            yield return value;
            try {
                value += step;
            }
            catch (OverflowException) {
                break;
            }
            --count;
        }
        yield break;
    }
}

public static class IntLoopExtension {

    public static Loop Times (this int self) {
        return new Loop (self);
    }

}
ddur answered 2020-01-24T01:39:34Z
1 votes
while (i-- > 0) {

}

您提到了while循环很危险,因为它可能是无限的-上面的形式非常简单,并且永远不会无限。 至少TOTALLY无限:)

它既方便又简短(比任何其他答案都短),并且将精确地运行i次(因为后缀减量在减量之前返回值)。

aaimnr answered 2020-01-24T01:39:58Z
translate from https://stackoverflow.com:/questions/3932413/is-there-a-shorter-simpler-version-of-the-for-loop-to-anything-x-times