Existe-t-il une version plus courte/simple de la boucle for pour faire quelque chose x fois ?

Question

Habituellement, nous faisons quelque chose comme une boucle for ou while avec un compteur :

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

mais parfois tu te mélanges avec les limites. Vous pourriez utiliser une boucle while à la place, mais si vous faites une erreur, cette boucle est infinie...

En Perl, par exemple, j'utiliserais la méthode plus évidente suivante

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

Y a-t-il quelque chose comme doitXtimes(10){...} ?

Answer 1

Il y a encore un chemin qui manque :

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

Où T est le type renvoyé par GetRandomItem()

Answer 2

Exemple 1

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

Exemple 2

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

Exemple 3

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

Classe et extension de la boucle

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);
    }

}