Is there an elegant way to repeat an action?

Question

In C#, using .NET Framework 4, is there an elegant way to repeat the same action a determined number of times? For example, instead of:

int repeat = 10;
for (int i = 0; i < repeat; i++)
{
    Console.WriteLine("Hello World.");
    this.DoSomeStuff();
}

I would like to write something like:

Action toRepeat = () =>
{
    Console.WriteLine("Hello World.");
    this.DoSomeStuff();
};

toRepeat.Repeat(10);

or:

Enumerable.Repeat(10, () =>
{
    Console.WriteLine("Hello World.");
    this.DoSomeStuff();
});

I know I can create my own extension method for the first example, but isn't there an existent feature which makes it already possible to do this?

Answer 1

Like this?

using System.Linq;

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

This will execute your method 10 times.

[Edit]

I am so used to having ForEach extension method on Enumerable, that I forgot it is not part of FCL.

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
    foreach (var item in source)
        action(item);
}

Here is what you can do without ForEach extension method:

Enumerable.Range(0, 10).ToList().ForEach(arg => toRepeat());

[Edit]

I think that the most elegant solution is to implement reusable method:

public static void RepeatAction(int repeatCount, Action action)
{
    for (int i = 0; i < repeatCount; i++)
        action();
}

Usage:

RepeatAction(10, () => { Console.WriteLine("Hello World."); });

Answer 2

There is no built-in way to do this.

The reason is that C# as it is tries to enforce a divide between the functional and imperative sides of the language. C# only makes it easy to do functional programming when it is not going to produce side effects. Thus you get collection-manipulation methods like LINQ's Where, Select, etc., but you do not get ForEach.¹

In a similar way, what you are trying to do here is find some functional way of expressing what is essentially an imperative action. Although C# gives you the tools to do this, it does not try to make it easy for you, as doing so makes your code unclear and non-idiomatic.

¹ There is a List<T>.ForEach, but not an IEnumerable<T>.ForEach. I would say the existence of List<T>.ForEach is a historical artifact stemming from the framework designers not having thought through these issues around the time of .NET 2.0; the need for a clear division only became apparent in 3.0.

Answer 3

For brevity of a one liner you could do this. Not sure what you think...

Enumerable.Repeat<Action>(() => 
{
    Console.WriteLine("Hello World.");
    this.DoSomeStuff();
}, 10).ToList().ForEach(x => x());

Answer 4

Without rolling out your own extension, I guess you can do something like this

    Action toRepeat = () => {
        Console.WriteLine("Hello World.");
         this.DoSomeStuff();
    };

    int repeat = 10;
    Enumerable.Range(0, repeat).ToList().ForEach(i => toRepeat());

Answer 5

Enumerable.Repeat<Action>(() => { Console.WriteLine("Hello World"); this.DoSomething(); },10).ToList().ForEach(f => f.Invoke());

elegant isn't it?

Answer 6

Most convenient I find is:

Enumerable.Range(0, 10).Select(_ => action());

Answer 7

I wrote it as an Int32 extension method. At first I thought maybe that doesn't sound like a good idea, but it actually seems really great when you use it.

public static void Repeat(
   this int count,
   Action action
) {
   for (int x = 0; x < count; x += 1)
      action();
}

Usage:

5.Repeat(DoThing);

value.Repeat(() => queue.Enqueue(someItem));

(value1 - value2).Repeat(() => {
   // complex implementation
});

Note that it will do nothing for values <= 0. At first I was going to throw for negatives, but then I'd always have to check which number is greater when comparing two. This allows a difference to work if positive and do nothing otherwise.

You could write an Abs extension method (either value.Abs().Repeat(() => { }); or -5.RepeatAbs(() => { });) if you wanted to repeat regardless of sign and then the order of the difference of two numbers wouldn't matter.

Other variants are possible as well, like passing the index, or projecting into values similar to Select.

I know there is Enumerable.Range but this is a lot more concise.

Answer 8

Table table = frame.AddTable();
int columnsCount = 7;

Enumerable.Repeat<Func<Column>>(table.AddColumn, columnsCount)
          .ToList()
          .ForEach(addColumn => addColumn());
//or
Enumerable.Range(0, columnsCount)
          .ToList()
          .ForEach(iteration => table.AddColumn());

these options are not elegant because of ToList(), but both worked in my case

Answer 9

Declare an extension:

public static void Repeat(this Action action, int times){
    while (times-- > 0)
        action.Invoke();
}

You can use the extension method as:

        new Action(() =>
                   {
                       Console.WriteLine("Hello World.");
                       this.DoSomeStuff();
                   }).Repeat(10);

Answer 10

If your action is thread-safe you could use

Parallel.For(0, 10, i => myAction(schema));

Answer 11

This repeats twice, there is also a iteration variable for your convenience:

foreach (var iteration in Enumerable.Range(0, 2))
{
     // do stuff
}