LINQ equivalent of foreach for IEnumerable T

Question

I d like to do the equivalent of the following in LINQ  but I can t figure out how   IEnumerable lt Item gt  items   GetItems    items ForEach i   gt  i DoStuff       What is the real syntax

User · Answer

There is an experimental release by Microsoft of Interactive Extensions to LINQ (also on NuGet, see RxTeams's profile for more links). The Channel 9 video explains it well.

Its docs are only provided in XML format. I have run this documentation in Sandcastle to allow it to be in a more readable format. Unzip the docs archive and look for index.html.

Among many other goodies, it provides the expected ForEach implementation. It allows you to write code like this:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

User · Answer

Many people mentioned it  but I had to write it down  Isn t this most clear most readable   IEnumerable lt Item gt  items   GetItems    foreach  var item in items  item DoStuff      Short and simple st

User · Answer

There is no ForEach extension for IEnumerable  only for List lt T gt   So you could do  items ToList   ForEach i   gt  i DoStuff       Alternatively  write your own ForEach extension method   public static void ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach T item in enumeration                action item

User · Answer

There is no ForEach extension for IEnumerable  only for List lt T gt   So you could do  items ToList   ForEach i   gt  i DoStuff       Alternatively  write your own ForEach extension method   public static void ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach T item in enumeration                action item

User · Answer

Fredrik has provided the fix  but it may be worth considering why this isn t in the framework to start with  I believe the idea is that the LINQ query operators should be side-effect-free  fitting in with a reasonably functional way of looking at the world  Clearly ForEach is exactly the opposite - a purely side-effect-based construct   That s not to say this is a bad thing to do - just thinking about the philosophical reasons behind the decision

User · Answer

Now we have the option of             ParallelOptions parallelOptions   new ParallelOptions            parallelOptions MaxDegreeOfParallelism   4   if DEBUG         parallelOptions MaxDegreeOfParallelism   1   endif         Parallel ForEach bookIdList  parallelOptions  bookID   gt  UpdateStockCount bookID      Of course  this opens up a whole new can of threadworms   ps  Sorry about the fonts  it s what the system decided

User · Answer

Keep your Side Effects out of my IEnumerable          I d like to do the equivalent of the following in LINQ  but I can t figure out how       As others have pointed out here and abroad LINQ and IEnumerable methods are expected to be side-effect free    Do you really want to  do something  to each item in the IEnumerable  Then foreach is the best choice  People aren t surprised when side-effects happen here    foreach  var i in items  i DoStuff      I bet you don t want a side-effect  However in my experience side-effects are usually not required  More often than not there is a simple LINQ query waiting to be discovered accompanied by a StackOverflow com answer by either Jon Skeet  Eric Lippert  or Marc Gravell explaining how to do what you want   Some examples  If you are actually just aggregating  accumulating  some value then you should consider the Aggregate extension method   items Aggregate initial   acc  x    gt  ComputeAccumulatedValue acc  x      Perhaps you want to create a new IEnumerable from the existing values    items Select x   gt  Transform x      Or maybe you want to create a look-up table   items ToLookup x  x   gt  GetTheKey x     The list  pun not entirely intended  of possibilities goes on and on

User · Answer

According to PLINQ  available since  Net 4 0   you can do an  IEnumerable lt T gt  AsParallel   ForAll      to do a parallel foreach loop on an IEnumerable

User · Answer

I respectually disagree with the notion that link extension methods should be side-effect free  not only because they aren t  any delegate can perform side effects    Consider the following      public class Element        public Enum ProcessType            This   0  That   1  SomethingElse   2          public class Class1            private Dictionary lt ProcessType  Action lt Element gt  gt  actions             new Dictionary lt ProcessType Action lt Element gt  gt            public Class1                    actions Add  ProcessType This  DoThis             actions Add  ProcessType That  DoThat             actions Add  ProcessType SomethingElse  DoSomethingElse                      Element actions            This example defines 3 distict actions          that can be applied to individual elements           But for the sake of the argument  make          no assumption about how many distict          actions there may  and that there could          possibly be many more         public void DoThis  Element element                       Do something to element                public void DoThat  Element element                       Do something to element                public void DoSomethingElse  Element element                       Do something to element                public void Apply  ProcessType processType  IEnumerable lt Element gt  elements                    Action lt Element gt  action   null           if    actions TryGetValue  processType  out action                 throw new ArgumentException  processType             foreach  element in elements                action element                  What the example shows is really just a kind of late-binding that allows one invoke one of many possible actions having side-effects on a sequence of elements  without having to write a big switch construct to decode the value that defines the action and translate it into its corresponding method

User · Answer

For VB NET you should use   listVariable ForEach Sub i  i Property    Value

User · Answer

You could use the FirstOrDefault   extension  which is available for IEnumerable lt T gt   By returning false from the predicate  it will be run for each element but will not care that it doesn t actually find a match  This will avoid the ToList   overhead   IEnumerable lt Item gt  items   GetItems    items FirstOrDefault i   gt    i DoStuff    return false

User · Answer

Yet another ForEach Example   public static IList lt AddressEntry gt  MapToDomain IList lt AddressModel gt  addresses        var workingAddresses   new List lt AddressEntry gt          addresses Select a   gt  a  ToList   ForEach a   gt  workingAddresses Add AddressModelMapper MapToDomain a          return workingAddresses

User · Answer

Inspired by Jon Skeet  I have extended his solution with the following   Extension Method   public static void Execute lt TSource  TKey gt  this IEnumerable lt TSource gt  source  Action lt TKey gt  applyBehavior  Func lt TSource  TKey gt  keySelector        foreach  var item in source                var target   keySelector item           applyBehavior target             Client   var jobs   new List lt Job gt                    new Job   Id    XAML Developer              new Job   Id    Assassin              new Job   Id    Narco Trafficker            jobs Execute ApplyFilter  j   gt  j Id                public void ApplyFilter string filterId                Debug WriteLine filterId

User · Answer

If you want to act as the enumeration rolls you should yield each item   public static class EnumerableExtensions       public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action                foreach  var item in enumeration                        action item               yield return item

User · Answer

You could use the FirstOrDefault   extension  which is available for IEnumerable lt T gt   By returning false from the predicate  it will be run for each element but will not care that it doesn t actually find a match  This will avoid the ToList   overhead   IEnumerable lt Item gt  items   GetItems    items FirstOrDefault i   gt    i DoStuff    return false

User · Answer

The purpose of ForEach is to cause side effects  IEnumerable is for lazy enumeration of a set   This conceptual difference is quite visible when you consider it   SomeEnumerable ForEach item  gt DataStore Synchronize item     This wont execute until you do a  count  or a  ToList    or something on it  It clearly is not what is expressed   You should use the IEnumerable extensions for setting up chains of iteration  definining content by their respective sources and conditions  Expression Trees are powerful and efficient  but you should learn to appreciate their nature  And not just for programming around them to save a few characters overriding lazy evaluation

User · Answer

Fredrik has provided the fix  but it may be worth considering why this isn t in the framework to start with  I believe the idea is that the LINQ query operators should be side-effect-free  fitting in with a reasonably functional way of looking at the world  Clearly ForEach is exactly the opposite - a purely side-effect-based construct   That s not to say this is a bad thing to do - just thinking about the philosophical reasons behind the decision

User · Answer

Fredrik has provided the fix  but it may be worth considering why this isn t in the framework to start with  I believe the idea is that the LINQ query operators should be side-effect-free  fitting in with a reasonably functional way of looking at the world  Clearly ForEach is exactly the opposite - a purely side-effect-based construct   That s not to say this is a bad thing to do - just thinking about the philosophical reasons behind the decision

User · Answer

So many answers  yet ALL fail to pinpoint one very significant problem with a custom generic ForEach extension  Performance  And more specifically  memory usage and GC  Consider the sample below  Targeting  NET Framework 4 7 2 or  NET Core 3 1 401  configuration is Release and platform is Any CPU  public static class Enumerables       public static void ForEach lt T gt  this IEnumerable lt T gt   this  Action lt T gt  action                foreach  T item in  this                        action item                      class Program       private static void NoOp int value          static void Main string   args                var list   Enumerable Range 0  10  ToList            for  int i   0  i  lt  1000000  i                             WithLinq list                  WithoutLinqNoGood list               WithoutLinq list                        private static void WithoutLinq List lt int gt  list                foreach  var item in list                        NoOp item                        private static void WithLinq IEnumerable lt int gt  list    gt  list ForEach NoOp        private static void WithoutLinqNoGood IEnumerable lt int gt  enumerable                foreach  var item in enumerable                        NoOp item                      At a first glance  all three variants should perform equally well  However  when the ForEach extension method is called many  many times  you will end up with garbage that implies a costly GC  In fact  having this ForEach extension method on a hot path has been proven to totally kill performance in our loop-intensive application  Similarly  the weekly typed foreach loop will also produce garbage  but it will still be faster and less memory-intensive than the ForEach extension  which also suffers from a delegate allocation   Strongly typed foreach  Memory usage  Weekly typed foreach  Memory usage  ForEach extension  Memory usage  Analysis For a strongly typed foreach the compiler is able to use any optimized enumerator  e g  value based  of a class  whereas a generic ForEach extension must fall back to a generic enumerator which will be allocated on each run  Furthermore  the actual delegate will also imply an additional allocation  You would get similar bad results with the WithoutLinqNoGood method  There  the argument is of type IEnumerable lt int gt  instead of List lt int gt  implying the same type of enumerator allocation  Below are the relevant differences in IL  A value based enumerator is certainly preferable  IL 0001   callvirt   instance class            mscorlib System Collections Generic IEnumerator 1 lt  0 gt             class  mscorlib System Collections Generic IEnumerable 1 lt   T gt   GetEnumerator    vs IL 0001   callvirt   instance valuetype            mscorlib System Collections Generic List 1 Enumerator lt  0 gt            class  mscorlib System Collections Generic List 1 lt int32 gt   GetEnumerator    Conclusion The OP asked how to call ForEach   on an IEnumerable lt T gt   The original answer clearly shows how it can be done  Sure you can do it  but then again  my answer clearly shows that you shouldn t  Verified the same behavior when targeting  NET Core 3 1 401  compiling with Visual Studio 16 7 2

User · Answer

Many people mentioned it  but I had to write it down  Isn t this most clear most readable   IEnumerable lt Item gt  items   GetItems    foreach  var item in items  item DoStuff      Short and simple st

User · Answer

So many answers  yet ALL fail to pinpoint one very significant problem with a custom generic ForEach extension  Performance  And more specifically  memory usage and GC  Consider the sample below  Targeting  NET Framework 4 7 2 or  NET Core 3 1 401  configuration is Release and platform is Any CPU  public static class Enumerables       public static void ForEach lt T gt  this IEnumerable lt T gt   this  Action lt T gt  action                foreach  T item in  this                        action item                      class Program       private static void NoOp int value          static void Main string   args                var list   Enumerable Range 0  10  ToList            for  int i   0  i  lt  1000000  i                             WithLinq list                  WithoutLinqNoGood list               WithoutLinq list                        private static void WithoutLinq List lt int gt  list                foreach  var item in list                        NoOp item                        private static void WithLinq IEnumerable lt int gt  list    gt  list ForEach NoOp        private static void WithoutLinqNoGood IEnumerable lt int gt  enumerable                foreach  var item in enumerable                        NoOp item                      At a first glance  all three variants should perform equally well  However  when the ForEach extension method is called many  many times  you will end up with garbage that implies a costly GC  In fact  having this ForEach extension method on a hot path has been proven to totally kill performance in our loop-intensive application  Similarly  the weekly typed foreach loop will also produce garbage  but it will still be faster and less memory-intensive than the ForEach extension  which also suffers from a delegate allocation   Strongly typed foreach  Memory usage  Weekly typed foreach  Memory usage  ForEach extension  Memory usage  Analysis For a strongly typed foreach the compiler is able to use any optimized enumerator  e g  value based  of a class  whereas a generic ForEach extension must fall back to a generic enumerator which will be allocated on each run  Furthermore  the actual delegate will also imply an additional allocation  You would get similar bad results with the WithoutLinqNoGood method  There  the argument is of type IEnumerable lt int gt  instead of List lt int gt  implying the same type of enumerator allocation  Below are the relevant differences in IL  A value based enumerator is certainly preferable  IL 0001   callvirt   instance class            mscorlib System Collections Generic IEnumerator 1 lt  0 gt             class  mscorlib System Collections Generic IEnumerable 1 lt   T gt   GetEnumerator    vs IL 0001   callvirt   instance valuetype            mscorlib System Collections Generic List 1 Enumerator lt  0 gt            class  mscorlib System Collections Generic List 1 lt int32 gt   GetEnumerator    Conclusion The OP asked how to call ForEach   on an IEnumerable lt T gt   The original answer clearly shows how it can be done  Sure you can do it  but then again  my answer clearly shows that you shouldn t  Verified the same behavior when targeting  NET Core 3 1 401  compiling with Visual Studio 16 7 2

User · Answer

Fredrik has provided the fix  but it may be worth considering why this isn t in the framework to start with  I believe the idea is that the LINQ query operators should be side-effect-free  fitting in with a reasonably functional way of looking at the world  Clearly ForEach is exactly the opposite - a purely side-effect-based construct   That s not to say this is a bad thing to do - just thinking about the philosophical reasons behind the decision

User · Answer

This  functional approach  abstraction leaks big time  Nothing on the language level prevents side effects  As long as you can make it call your lambda delegate for every element in the container - you will get the  ForEach  behavior   Here for example one way of merging srcDictionary into destDictionary  if key already exists - overwrites   this is a hack  and should not be used in any production code   var b   srcDictionary Select                               x  gt                                                                      destDictionary x Key    x Value                                    return true                                                                   Count

User · Answer

To stay fluent one can use such a trick   GetItems        Select i   gt  new Action i DoStuf         Aggregate  a  b    gt  a   b       Invoke

User · Answer

There is an experimental release by Microsoft of Interactive Extensions to LINQ (also on NuGet, see RxTeams's profile for more links). The Channel 9 video explains it well.

Its docs are only provided in XML format. I have run this documentation in Sandcastle to allow it to be in a more readable format. Unzip the docs archive and look for index.html.

Among many other goodies, it provides the expected ForEach implementation. It allows you to write code like this:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

User · Answer

Now we have the option of             ParallelOptions parallelOptions   new ParallelOptions            parallelOptions MaxDegreeOfParallelism   4   if DEBUG         parallelOptions MaxDegreeOfParallelism   1   endif         Parallel ForEach bookIdList  parallelOptions  bookID   gt  UpdateStockCount bookID      Of course  this opens up a whole new can of threadworms   ps  Sorry about the fonts  it s what the system decided

User · Answer

If you want to act as the enumeration rolls you should yield each item   public static class EnumerableExtensions       public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action                foreach  var item in enumeration                        action item               yield return item

User · Answer

Keep your Side Effects out of my IEnumerable          I d like to do the equivalent of the following in LINQ  but I can t figure out how       As others have pointed out here and abroad LINQ and IEnumerable methods are expected to be side-effect free    Do you really want to  do something  to each item in the IEnumerable  Then foreach is the best choice  People aren t surprised when side-effects happen here    foreach  var i in items  i DoStuff      I bet you don t want a side-effect  However in my experience side-effects are usually not required  More often than not there is a simple LINQ query waiting to be discovered accompanied by a StackOverflow com answer by either Jon Skeet  Eric Lippert  or Marc Gravell explaining how to do what you want   Some examples  If you are actually just aggregating  accumulating  some value then you should consider the Aggregate extension method   items Aggregate initial   acc  x    gt  ComputeAccumulatedValue acc  x      Perhaps you want to create a new IEnumerable from the existing values    items Select x   gt  Transform x      Or maybe you want to create a look-up table   items ToLookup x  x   gt  GetTheKey x     The list  pun not entirely intended  of possibilities goes on and on

User · Answer

There is no ForEach extension for IEnumerable  only for List lt T gt   So you could do  items ToList   ForEach i   gt  i DoStuff       Alternatively  write your own ForEach extension method   public static void ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach T item in enumeration                action item

User · Answer

MoreLinq has IEnumerable lt T gt  ForEach and a ton of other useful extensions  It s probably not worth taking the dependency just for ForEach  but there s a lot of useful stuff in there   https   www nuget org packages morelinq   https   github com morelinq MoreLINQ

User · Answer

MoreLinq has IEnumerable lt T gt  ForEach and a ton of other useful extensions  It s probably not worth taking the dependency just for ForEach  but there s a lot of useful stuff in there   https   www nuget org packages morelinq   https   github com morelinq MoreLINQ

User · Answer

ForEach can also be Chained  just put back to the pileline after the action  remain fluent    Employees ForEach e  gt e Act A            ForEach e  gt e Act B            ForEach e  gt e Act C    Orders    just for demo      ForEach o  gt  o EmailBuyer          ForEach o  gt  o ProcessBilling          ForEach o  gt  o ProcessShipping         conditional Employees      ForEach e  gt     if e Salary lt 1000  e Raise 0 10          ForEach e  gt     if e Age    gt 70    e Retire           An Eager version of implementation   public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enu  Action lt T gt  action        foreach  T item in enu  action item       return enu     make action Chainable Fluent     Edit  a Lazy version is using yield return  like this   public static IEnumerable lt T gt  ForEachLazy lt T gt  this IEnumerable lt T gt  enu  Action lt T gt  action        foreach  var item in enu                action item           yield return item            The Lazy version NEEDs to be materialized  ToList   for example  otherwise  nothing happens  see below great comments from ToolmakerSteve   IQueryable lt Product gt  query   Products Where       query ForEachLazy t   gt  t Price   t Price   1 00       ToList      without this line  below SubmitChanges   does nothing  SubmitChanges      I keep both ForEach   and ForEachLazy   in my library

User · Answer

ForEach can also be Chained  just put back to the pileline after the action  remain fluent    Employees ForEach e  gt e Act A            ForEach e  gt e Act B            ForEach e  gt e Act C    Orders    just for demo      ForEach o  gt  o EmailBuyer          ForEach o  gt  o ProcessBilling          ForEach o  gt  o ProcessShipping         conditional Employees      ForEach e  gt     if e Salary lt 1000  e Raise 0 10          ForEach e  gt     if e Age    gt 70    e Retire           An Eager version of implementation   public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enu  Action lt T gt  action        foreach  T item in enu  action item       return enu     make action Chainable Fluent     Edit  a Lazy version is using yield return  like this   public static IEnumerable lt T gt  ForEachLazy lt T gt  this IEnumerable lt T gt  enu  Action lt T gt  action        foreach  var item in enu                action item           yield return item            The Lazy version NEEDs to be materialized  ToList   for example  otherwise  nothing happens  see below great comments from ToolmakerSteve   IQueryable lt Product gt  query   Products Where       query ForEachLazy t   gt  t Price   t Price   1 00       ToList      without this line  below SubmitChanges   does nothing  SubmitChanges      I keep both ForEach   and ForEachLazy   in my library

User · Answer

I respectually disagree with the notion that link extension methods should be side-effect free  not only because they aren t  any delegate can perform side effects    Consider the following      public class Element        public Enum ProcessType            This   0  That   1  SomethingElse   2          public class Class1            private Dictionary lt ProcessType  Action lt Element gt  gt  actions             new Dictionary lt ProcessType Action lt Element gt  gt            public Class1                    actions Add  ProcessType This  DoThis             actions Add  ProcessType That  DoThat             actions Add  ProcessType SomethingElse  DoSomethingElse                      Element actions            This example defines 3 distict actions          that can be applied to individual elements           But for the sake of the argument  make          no assumption about how many distict          actions there may  and that there could          possibly be many more         public void DoThis  Element element                       Do something to element                public void DoThat  Element element                       Do something to element                public void DoSomethingElse  Element element                       Do something to element                public void Apply  ProcessType processType  IEnumerable lt Element gt  elements                    Action lt Element gt  action   null           if    actions TryGetValue  processType  out action                 throw new ArgumentException  processType             foreach  element in elements                action element                  What the example shows is really just a kind of late-binding that allows one invoke one of many possible actions having side-effects on a sequence of elements  without having to write a big switch construct to decode the value that defines the action and translate it into its corresponding method

User · Answer

To stay fluent one can use such a trick   GetItems        Select i   gt  new Action i DoStuf         Aggregate  a  b    gt  a   b       Invoke

User · Answer

As numerous answers already point out  you can easily add such an extension method yourself  However  if you don t want to do that  although I m not aware of anything like this in the BCL  there s still an option in the System namespace  if you already have a reference to Reactive Extension  and if you don t  you should have    using System Reactive Linq   items ToObservable   Subscribe i   gt  i DoStuff       Although the method names are a bit different  the end result is exactly what you re looking for

User · Answer

I took Fredrik s method and modified the return type   This way  the method supports deferred execution like other LINQ methods   EDIT  If this wasn t clear  any usage of this method must end with ToList   or any other way to force the method to work on the complete enumerable  Otherwise  the action would not be performed   public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach  T item in enumeration                action item           yield return item            And here s the test to help see it    Test  public void TestDefferedExecutionOfIEnumerableForEach         IEnumerable lt char gt  enumerable   new     a    b    c         var sb   new StringBuilder         enumerable          ForEach c   gt  sb Append  1             ForEach c   gt  sb Append  2             ToList         Assert That sb ToString    Is EqualTo  121212         If you remove the ToList   in the end  you will see the test failing since the StringBuilder contains an empty string  This is because no method forced the ForEach to enumerate

User · Answer

I took Fredrik s method and modified the return type   This way  the method supports deferred execution like other LINQ methods   EDIT  If this wasn t clear  any usage of this method must end with ToList   or any other way to force the method to work on the complete enumerable  Otherwise  the action would not be performed   public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach  T item in enumeration                action item           yield return item            And here s the test to help see it    Test  public void TestDefferedExecutionOfIEnumerableForEach         IEnumerable lt char gt  enumerable   new     a    b    c         var sb   new StringBuilder         enumerable          ForEach c   gt  sb Append  1             ForEach c   gt  sb Append  2             ToList         Assert That sb ToString    Is EqualTo  121212         If you remove the ToList   in the end  you will see the test failing since the StringBuilder contains an empty string  This is because no method forced the ForEach to enumerate

User · Answer

This  functional approach  abstraction leaks big time  Nothing on the language level prevents side effects  As long as you can make it call your lambda delegate for every element in the container - you will get the  ForEach  behavior   Here for example one way of merging srcDictionary into destDictionary  if key already exists - overwrites   this is a hack  and should not be used in any production code   var b   srcDictionary Select                               x  gt                                                                      destDictionary x Key    x Value                                    return true                                                                   Count

User · Answer

For VB NET you should use   listVariable ForEach Sub i  i Property    Value

User · Answer

Inspired by Jon Skeet  I have extended his solution with the following   Extension Method   public static void Execute lt TSource  TKey gt  this IEnumerable lt TSource gt  source  Action lt TKey gt  applyBehavior  Func lt TSource  TKey gt  keySelector        foreach  var item in source                var target   keySelector item           applyBehavior target             Client   var jobs   new List lt Job gt                    new Job   Id    XAML Developer              new Job   Id    Assassin              new Job   Id    Narco Trafficker            jobs Execute ApplyFilter  j   gt  j Id                public void ApplyFilter string filterId                Debug WriteLine filterId

User · Answer

There is no ForEach extension for IEnumerable  only for List lt T gt   So you could do  items ToList   ForEach i   gt  i DoStuff       Alternatively  write your own ForEach extension method   public static void ForEach lt T gt  this IEnumerable lt T gt  enumeration  Action lt T gt  action        foreach T item in enumeration                action item

User · Answer

Update 7 17 2012  Apparently as of C  5 0  the behavior of foreach described below has been changed and  the use of a foreach iteration variable in a nested lambda expression no longer produces unexpected results   This answer does not apply to C    5 0     John Skeet and everyone who prefers the foreach keyword   The problem with  foreach  in C  prior to 5 0  is that it is inconsistent with how the equivalent  for comprehension  works in other languages  and with how I would expect it to work  personal opinion stated here only because others have mentioned their opinion regarding readability    See all of the questions concerning  Access to modified closure  as well as  Closing over the loop variable considered harmful    This is only  harmful  because of the way  foreach  is implemented in C    Take the following examples using the functionally equivalent extension method to that in  Fredrik Kalseth s answer   public static class Enumerables       public static void ForEach lt T gt  this IEnumerable lt T gt   this  Action lt T gt  action                foreach  T item in  this                        action item                       Apologies for the overly contrived example   I m only using Observable because it s not entirely far fetched to do something like this  Obviously there are better ways to create this observable  I am only attempting to demonstrate a point   Typically the code subscribed to the observable is executed asynchronously and potentially in another thread   If using  foreach   this could produce very strange and potentially non-deterministic results   The following test using  ForEach  extension method passes    Test  public void ForEachExtensionWin           Yes  I know there is an Observable Range      var values   Enumerable Range 0  10        var observable   Observable Create lt Func lt int gt  gt  source   gt                                                                values ForEach value   gt                                       source OnNext      gt  value                                     source OnCompleted                                    return      gt                                              Simulate subscribing and evaluating Funcs     var evaluatedObservable   observable ToEnumerable   Select func   gt  func    ToList           Win     Assert That evaluatedObservable           Is EquivalentTo values ToList          The following fails with the error   Expected  equivalent to  lt  0  1  2  3  4  5  6  7  8  9       But was    lt  9  9  9  9  9  9  9  9  9  9     Test  public void ForEachKeywordFail           Yes  I know there is an Observable Range      var values   Enumerable Range 0  10        var observable   Observable Create lt Func lt int gt  gt  source   gt                                                                foreach  var value in values                                                                          If you have resharper  notice the warning                                     source OnNext      gt  value                                                                     source OnCompleted                                    return      gt                                              Simulate subscribing and evaluating Funcs     var evaluatedObservable   observable ToEnumerable   Select func   gt  func    ToList           Fail     Assert That evaluatedObservable           Is EquivalentTo values ToList

User · Answer

Yet another ForEach Example   public static IList lt AddressEntry gt  MapToDomain IList lt AddressModel gt  addresses        var workingAddresses   new List lt AddressEntry gt          addresses Select a   gt  a  ToList   ForEach a   gt  workingAddresses Add AddressModelMapper MapToDomain a          return workingAddresses

User · Answer

The purpose of ForEach is to cause side effects  IEnumerable is for lazy enumeration of a set   This conceptual difference is quite visible when you consider it   SomeEnumerable ForEach item  gt DataStore Synchronize item     This wont execute until you do a  count  or a  ToList    or something on it  It clearly is not what is expressed   You should use the IEnumerable extensions for setting up chains of iteration  definining content by their respective sources and conditions  Expression Trees are powerful and efficient  but you should learn to appreciate their nature  And not just for programming around them to save a few characters overriding lazy evaluation

User · Answer

As numerous answers already point out  you can easily add such an extension method yourself  However  if you don t want to do that  although I m not aware of anything like this in the BCL  there s still an option in the System namespace  if you already have a reference to Reactive Extension  and if you don t  you should have    using System Reactive Linq   items ToObservable   Subscribe i   gt  i DoStuff       Although the method names are a bit different  the end result is exactly what you re looking for

User · Answer

According to PLINQ  available since  Net 4 0   you can do an  IEnumerable lt T gt  AsParallel   ForAll      to do a parallel foreach loop on an IEnumerable

User · Answer

Update 7 17 2012  Apparently as of C  5 0  the behavior of foreach described below has been changed and  the use of a foreach iteration variable in a nested lambda expression no longer produces unexpected results   This answer does not apply to C    5 0     John Skeet and everyone who prefers the foreach keyword   The problem with  foreach  in C  prior to 5 0  is that it is inconsistent with how the equivalent  for comprehension  works in other languages  and with how I would expect it to work  personal opinion stated here only because others have mentioned their opinion regarding readability    See all of the questions concerning  Access to modified closure  as well as  Closing over the loop variable considered harmful    This is only  harmful  because of the way  foreach  is implemented in C    Take the following examples using the functionally equivalent extension method to that in  Fredrik Kalseth s answer   public static class Enumerables       public static void ForEach lt T gt  this IEnumerable lt T gt   this  Action lt T gt  action                foreach  T item in  this                        action item                       Apologies for the overly contrived example   I m only using Observable because it s not entirely far fetched to do something like this  Obviously there are better ways to create this observable  I am only attempting to demonstrate a point   Typically the code subscribed to the observable is executed asynchronously and potentially in another thread   If using  foreach   this could produce very strange and potentially non-deterministic results   The following test using  ForEach  extension method passes    Test  public void ForEachExtensionWin           Yes  I know there is an Observable Range      var values   Enumerable Range 0  10        var observable   Observable Create lt Func lt int gt  gt  source   gt                                                                values ForEach value   gt                                       source OnNext      gt  value                                     source OnCompleted                                    return      gt                                              Simulate subscribing and evaluating Funcs     var evaluatedObservable   observable ToEnumerable   Select func   gt  func    ToList           Win     Assert That evaluatedObservable           Is EquivalentTo values ToList          The following fails with the error   Expected  equivalent to  lt  0  1  2  3  4  5  6  7  8  9       But was    lt  9  9  9  9  9  9  9  9  9  9     Test  public void ForEachKeywordFail           Yes  I know there is an Observable Range      var values   Enumerable Range 0  10        var observable   Observable Create lt Func lt int gt  gt  source   gt                                                                foreach  var value in values                                                                          If you have resharper  notice the warning                                     source OnNext      gt  value                                                                     source OnCompleted                                    return      gt                                              Simulate subscribing and evaluating Funcs     var evaluatedObservable   observable ToEnumerable   Select func   gt  func    ToList           Fail     Assert That evaluatedObservable           Is EquivalentTo values ToList

[linq] LINQ equivalent of foreach for IEnumerable<T>

Examples related to linq

Examples related to foreach

Examples related to ienumerable