Which is faster for arrays - foreach or for ( i... ) ?

[DoB]

Hi,

Given the following declaration:

object[] a = new object[SOME_BIG_NUMBER];

which code is faster?

1.
foreach ( object o in a )
DoSomethingWith(o);

2.
int iSize = a.Length;
int i;
foreach ( i = 0; i < iSize; i++ )
DoSomethingWith(a[i]);

And why?

Regards,
DoB

[DoB]

foreach ( i = 0; i < iSize; i++ )

Sorry, there was a typo here, of course ;-). should be "for".

DoB

[Alberto Poblacion]

"DoB" <Do*@dob.comwrote in message
news:ex**************@TK2MSFTNGP06.phx.gbl...

Given the following declaration:

object[] a = new object[SOME_BIG_NUMBER];

which code is faster?

1.
foreach ( object o in a )
DoSomethingWith(o);

2.
int iSize = a.Length;
int i;
foreach ( i = 0; i < iSize; i++ )
DoSomethingWith(a[i]);

And why?

In general, "for i" used with an array is faster than "foreach", the
reason being that "for i" only needs to increment and compare an integer and
do an indexing operation for every iteration, which are fast operations,
while "foreach" needs to call into IEnumerator to move to the next element
and then retrieve the current one. These are two method calls, in addition
to whatever is inside the methods, so it has a bigger overhead.

[Jon Skeet [C# MVP]]

On Feb 6, 9:50 am, "DoB" <[e-mail]:

Given the following declaration:

object[] a = new object[SOME_BIG_NUMBER];

which code is faster?

I wouldn't concentrate on which code is faster until I've proved it
matters - at which point I'd have numbers to compare if I made
changes.

I'd concentrate on which is more readable, and simpler - in which case
"foreach" wins in most situations.

Don't micro-optimise until you know you've got a problem - and if you
know you've got a problem, that should include hard figures, which
will make it easy to test changes.

Jon

[DoB]

Don't micro-optimise until you know you've got a problem - and if you

know you've got a problem, that should include hard figures, which
will make it easy to test changes.

I actually came across a situation in which I wanted to change "foreach" to
"for" for some reasons (not performance-related) and before making a change
I wanted to know what was an impact on performance.

DoB

[Jon Skeet [C# MVP]]

On Feb 6, 11:26 am, "DoB" <[e-mail]:

Don't micro-optimise until you know you've got a problem - and if you
know you've got a problem, that should include hard figures, which
will make it easy to test changes.

I actually came across a situation in which I wanted to change "foreach" to
"for" for some reasons (not performance-related) and before making a change
I wanted to know what was an impact on performance.

Miniscule either way, unless you're really, really not doing anything
in the loop. If you have performance concerns, measuring them is
crucial.

I wouldn't try to micro-optimise the for loop, btw. Just do:

for (int i=0; i < myArray.Length; i++)
{
}

instead of using the temporary variable. I seem to recall that this is
actually faster in some situations, but it's certainly more readable.

Jon

[DoB]

I wouldn't try to micro-optimise the for loop, btw. Just do:

>
for (int i=0; i < myArray.Length; i++)
{
}

instead of using the temporary variable. I seem to recall that this is
actually faster in some situations, but it's certainly more readable.

I've made some tests and... yes... you are absolutely right - this is a bit
faster.
Why? Optimisation?

DoB.

[Laura T.]

Just my 2 cents.. I find the Array.ForEach<most readable, but maybe not
the most efficient:

object[] arr = new object[SOME_BIG_NUMBER];
Array.ForEach<object>(arr, new Action<object>(DoSomething));

"Jon Skeet [C# MVP]" <sk***@pobox.comha scritto nel messaggio
news:2f**********************************@s37g2000 prg.googlegroups.com...

On Feb 6, 9:50 am, "DoB" <[e-mail]:

>Given the following declaration:

object[] a = new object[SOME_BIG_NUMBER];

which code is faster?

I wouldn't concentrate on which code is faster until I've proved it
matters - at which point I'd have numbers to compare if I made
changes.

I'd concentrate on which is more readable, and simpler - in which case
"foreach" wins in most situations.

Don't micro-optimise until you know you've got a problem - and if you
know you've got a problem, that should include hard figures, which
will make it easy to test changes.

Jon

[Ben Voigt [C++ MVP]]

Alberto Poblacion wrote:

"DoB" <Do*@dob.comwrote in message
news:ex**************@TK2MSFTNGP06.phx.gbl...

>Given the following declaration:

object[] a = new object[SOME_BIG_NUMBER];

which code is faster?

1.
foreach ( object o in a )
DoSomethingWith(o);

2.
int iSize = a.Length;
int i;
foreach ( i = 0; i < iSize; i++ )
DoSomethingWith(a[i]);

And why?

In general, "for i" used with an array is faster than "foreach", the
reason being that "for i" only needs to increment and compare an
integer and do an indexing operation for every iteration, which are
fast operations, while "foreach" needs to call into IEnumerator to
move to the next element and then retrieve the current one. These are
two method calls, in addition to whatever is inside the methods, so
it has a bigger overhead.

arrays are a special case for the foreach keyword, the compiler
automatically avoids using IEnumerator

[Dejan Stanic]

"Laura T." <LT*****@yahoo.comje napisal v sporocilo
news:%2****************@TK2MSFTNGP04.phx.gbl ...

Just my 2 cents.. I find the Array.ForEach<most readable, but maybe not
the most efficient:

Definitely not efficient.

LP,
Dejan

[DoB]

>I've made some tests and... yes... you are absolutely right - this is a

>bit
faster.
Why? Optimisation?

The JIT compiler recognises the pattern, and can remove the array
bounds check within the loop, as I understand it.

What is interesting, I tested in debug mode. Looks like it is optimised,
too.

DoB