foreach or List.ForEach

[Tripper]

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}

strings.ForEach (
delegate(string s)
{
// some operation
}
);

[Nicholas Paldino [.NET/C# MVP]]

Tripper,

I wouldn't say that there is a better way, really, since they pretty
much do the same thing.

The call to ForEach might be a little less performant, because you are
making a call through a delegate (which ultimately is slower than the code
in the braces).

However, I wouldn't say that this is a deal-killer, since LINQ is going
to be heavily based on anonymous delegates doing this kind of thing.

Personally, for something as simple as a foreach, I would just use
foreach, since it is that simple.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Tripper" <Tr*****@discus sions.microsoft .com> wrote in message
news:8E******** *************** ***********@mic rosoft.com...

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}

strings.ForEach (
delegate(string s)
{
// some operation
}
);

[Tripper]

Thanks Nicholas! I wonder then, when is a good time to use List.ForEach over
foreach? Maybe like this?

strings.ForEach (ProcessString) ;

vs.

foreach (s in strings)
{
ProcessString(s );
}

Thanks!

Tripp

"Nicholas Paldino [.NET/C# MVP]" wrote:

Tripper,

I wouldn't say that there is a better way, really, since they pretty
much do the same thing.

The call to ForEach might be a little less performant, because you are
making a call through a delegate (which ultimately is slower than the code
in the braces).

However, I wouldn't say that this is a deal-killer, since LINQ is going
to be heavily based on anonymous delegates doing this kind of thing.

Personally, for something as simple as a foreach, I would just use
foreach, since it is that simple.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Tripper" <Tr*****@discus sions.microsoft .com> wrote in message
news:8E******** *************** ***********@mic rosoft.com...

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}

strings.ForEach (
delegate(string s)
{
// some operation
}
);

[Nicholas Paldino [.NET/C# MVP]]

Tripp,

I would say that is a good time, if you want to reduce your code
profile. Then again, the effects are so minimal, I would say it is
inconsequential .
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Tripper" <Tr*****@discus sions.microsoft .com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Thanks Nicholas! I wonder then, when is a good time to use List.ForEach
over
foreach? Maybe like this?

strings.ForEach (ProcessString) ;

vs.

foreach (s in strings)
{
ProcessString(s );
}

Thanks!

Tripp

"Nicholas Paldino [.NET/C# MVP]" wrote:

Tripper,

I wouldn't say that there is a better way, really, since they pretty
much do the same thing.

The call to ForEach might be a little less performant, because you
are
making a call through a delegate (which ultimately is slower than the
code
in the braces).

However, I wouldn't say that this is a deal-killer, since LINQ is
going
to be heavily based on anonymous delegates doing this kind of thing.

Personally, for something as simple as a foreach, I would just use
foreach, since it is that simple.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Tripper" <Tr*****@discus sions.microsoft .com> wrote in message
news:8E******** *************** ***********@mic rosoft.com...

> Which is the better way to go and why?
>
> //trivial example
> List<string> strings = GetStrings();
> foreach (string s in strings)
> {
> // some operation;
> }
>
> strings.ForEach (
> delegate(string s)
> {
> // some operation
> }
> );

[Ignacio Machin \( .NET/ C# MVP \)]

Hi,

"Tripper" <Tr*****@discus sions.microsoft .com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Thanks Nicholas! I wonder then, when is a good time to use List.ForEach
over
foreach? Maybe like this?

strings.ForEach (ProcessString) ;

vs.

foreach (s in strings)
{
ProcessString(s );
}

Thanks!

In my opinion it should perform almost similar, I bet that the
implementation of ForEach is VERY similar to the second code snip, so you
would only be saving in a little typing

Frankly I prefer the second, let's say it's more evident for anybody coming
from any language.

--
Ignacio Machin,
ignacio.machin AT dot.state.fl.us
Florida Department Of Transportation

[Jon Shemitz]

Tripper wrote:

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}
Reflector shows that foreach on a List<string> is not optimized: It
does the full GetEnumerator/while MoveNext.
strings.ForEach (
delegate(string s)
{
// some operation
}

List<T>.ForEach , otoh, does a simple for loop, internal to the List<T>
class.

So, given the example you show, strings.ForEach might actually perform
a bit better: More overhead to call the delegate than to execute an
inline foreach body, but less loop control overhead.

If you were comparing

foreach (string s in strings)
SomeMethod(S);

to

strings.ForEach (SomeMethod);

I'd expect strings.ForEach to come out even farther ahead, although
any differences should be really modest.

Fwiw, I benchmarked "foreach (string s in strings) SomeMethod(S)" vs
"strings.ForEac h(SomeMethod);" with a 7 string list.

10x Inline: 43.58 microseconds.
10x ForEach: 18.72 microseconds.

--
<http://www.midnightbea ch.com>

[Jon Skeet [C# MVP]]

Tripper <Tr*****@discus sions.microsoft .com> wrote:

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}

strings.ForEach (
delegate(string s)
{
// some operation
}
);

I was surprised by the results I found when benchmarking, so thought
people might be interested:

using System;
using System.Diagnost ics;
using System.Collecti ons.Generic;

class Test
{
const int Iterations = 10000;
const int Size = 100000;

static void Main()
{
Stopwatch stopwatch = new Stopwatch();
List<string> list = new List<string>();
for (int i=0; i < Size; i++)
{
list.Add("x");
}

{
int sum = 0;

stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
foreach (string s in list)
{
sum += s.Length;
}
}
TimeSpan t1 = stopwatch.Elaps ed;

Console.WriteLi ne ("First version: {0} (correct? {1})",
t1, sum==Iterations *Size);
}

{
int sum = 0;
stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
list.ForEach (delegate(strin g s) { sum += s.Length; });
}
TimeSpan t2 = stopwatch.Elaps ed;

Console.WriteLi ne ("Second version: {0} (correct? {1})",
t2, sum==Iterations *Size);
}

{
int sum = 0;

Action<string> action = delegate(string s)
{
sum += s.Length;
};

stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
list.ForEach (action);
}
TimeSpan t3 = stopwatch.Elaps ed;

Console.WriteLi ne ("Third version: {0} (correct? {1})",
t3, sum==Iterations *Size);
}
}
}

Results:

First version: 00:00:11.509660 8 (correct? True)
Second version: 00:00:05.519300 6 (correct? True)
Third version: 00:00:05.525776 6 (correct? True)

Note that the "sum" variable is different in each case. I don't know
what the performance impact of having a single variable would be, but I
believe there *would* be a difference (primarily or possibly solely to
the first version) due to it being captured by the other delegates.

I'd expected foreach to claim a significant victory...

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Patrik Löwendahl [C# MVP]]

Jon,

will you blog on this so I can link it from mine?

--
Patrik Löwendahl [C# MVP]
http://www.lowendahl.net

Tripper <Tr*****@discus sions.microsoft .com> wrote:

Which is the better way to go and why?

//trivial example
List<string> strings = GetStrings();
foreach (string s in strings)
{
// some operation;
}
strings.ForEach (
delegate(string s)
{
// some operation
}
);

I was surprised by the results I found when benchmarking, so thought
people might be interested:

using System;
using System.Diagnost ics;
using System.Collecti ons.Generic;
class Test
{
const int Iterations = 10000;
const int Size = 100000;
static void Main()
{
Stopwatch stopwatch = new Stopwatch();
List<string> list = new List<string>();
for (int i=0; i < Size; i++)
{
list.Add("x");
}
{
int sum = 0;
stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
foreach (string s in list)
{
sum += s.Length;
}
}
TimeSpan t1 = stopwatch.Elaps ed;
Console.WriteLi ne ("First version: {0} (correct? {1})",
t1, sum==Iterations *Size);
}
{
int sum = 0;
stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
list.ForEach (delegate(strin g s) { sum += s.Length;
});
}
TimeSpan t2 = stopwatch.Elaps ed;
Console.WriteLi ne ("Second version: {0} (correct? {1})",
t2, sum==Iterations *Size);
}
{
int sum = 0;
Action<string> action = delegate(string s)
{
sum += s.Length;
};
stopwatch.Reset ();
stopwatch.Start ();
for (int i=0; i < Iterations; i++)
{
list.ForEach (action);
}
TimeSpan t3 = stopwatch.Elaps ed;
Console.WriteLi ne ("Third version: {0} (correct? {1})",
t3, sum==Iterations *Size);
}
}
}
Results:

First version: 00:00:11.509660 8 (correct? True)
Second version: 00:00:05.519300 6 (correct? True)
Third version: 00:00:05.525776 6 (correct? True)
Note that the "sum" variable is different in each case. I don't know
what the performance impact of having a single variable would be, but
I believe there *would* be a difference (primarily or possibly solely
to the first version) due to it being captured by the other delegates.

I'd expected foreach to claim a significant victory...

[Jon Skeet [C# MVP]]

Patrik Löwendahl [C# MVP] <pa************ **@home.se> wrote:

will you blog on this so I can link it from mine?

Yeah, okay - you talked me into it :) It might not be tonight though.
As an added bonus I'll have the "captured variable" version and another
one where the delegate is a method call.

Tonight's job is continuing with my C# 2.0 pages which I hope to finish
by the end of January. It's not that there'll be reams of stuff on
there, but I don't get a lot of free time these days...

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Willy Denoyette [MVP]]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...
| Tripper <Tr*****@discus sions.microsoft .com> wrote:
| > Which is the better way to go and why?
| >
| > //trivial example
| > List<string> strings = GetStrings();
| > foreach (string s in strings)
| > {
| > // some operation;
| > }
| >
| > strings.ForEach (
| > delegate(string s)
| > {
| > // some operation
| > }
| > );
|
| I was surprised by the results I found when benchmarking, so thought
| people might be interested:
|
| using System;
| using System.Diagnost ics;
| using System.Collecti ons.Generic;
|
| class Test
| {
| const int Iterations = 10000;
| const int Size = 100000;
|
| static void Main()
| {
| Stopwatch stopwatch = new Stopwatch();
| List<string> list = new List<string>();
| for (int i=0; i < Size; i++)
| {
| list.Add("x");
| }
|
| {
| int sum = 0;
|
| stopwatch.Reset ();
| stopwatch.Start ();
| for (int i=0; i < Iterations; i++)
| {
| foreach (string s in list)
| {
| sum += s.Length;
| }
| }
| TimeSpan t1 = stopwatch.Elaps ed;
|
| Console.WriteLi ne ("First version: {0} (correct? {1})",
| t1, sum==Iterations *Size);
| }
|
| {
| int sum = 0;
| stopwatch.Reset ();
| stopwatch.Start ();
| for (int i=0; i < Iterations; i++)
| {
| list.ForEach (delegate(strin g s) { sum += s.Length; });
| }
| TimeSpan t2 = stopwatch.Elaps ed;
|
| Console.WriteLi ne ("Second version: {0} (correct? {1})",
| t2, sum==Iterations *Size);
| }
|
| {
| int sum = 0;
|
| Action<string> action = delegate(string s)
| {
| sum += s.Length;
| };
|
| stopwatch.Reset ();
| stopwatch.Start ();
| for (int i=0; i < Iterations; i++)
| {
| list.ForEach (action);
| }
| TimeSpan t3 = stopwatch.Elaps ed;
|
| Console.WriteLi ne ("Third version: {0} (correct? {1})",
| t3, sum==Iterations *Size);
| }
| }
| }
|
| Results:
|
| First version: 00:00:11.509660 8 (correct? True)
| Second version: 00:00:05.519300 6 (correct? True)
| Third version: 00:00:05.525776 6 (correct? True)
|
| Note that the "sum" variable is different in each case. I don't know
| what the performance impact of having a single variable would be, but I
| believe there *would* be a difference (primarily or possibly solely to
| the first version) due to it being captured by the other delegates.
|
| I'd expected foreach to claim a significant victory...
|
|

Just add two lines, and watch the result...
...
stopwatch.Start ();
// Put the list into an array for performance
string[] sa = new string[list.Count]; <----
list.CopyTo(sa, 0); <----
for (int i=0; i != Iterations; i++)
{
foreach (string s in sa)
{
sum += s.Length;
}
}
...

Also, try to run the first two tests only, and watch the results....
Willy.