Runtime: Proposal: ForEach in Linq

[hajirazin]

Background:
I have seen many libraries have been Implementing custom extension method for LINQ. Most of the project I have work with has this extension method. Not all projects need all the methods from Libraries like MoreLinq.
Proposal:
My Proposal is to have ForEach extension method as part of LINQ.

[MarcoRossignoli]

You could follow this guide https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/api-review-process.md and write a formal proposal.

[jnm2]

When is enumerable.ForEach(item => { }) better than foreach (var item in enumerable) { }?

[svick]

Eric Lippert has an article on the topic.

I do find collection.foreach more natural to write, which is why I like ReSharper's postfix templates. But using those does not require changing LINQ.

[hajirazin]

@svick and @jnm2 It's equally important in IEnumerable because other Linq methods return IEnumerable. It's very much important when you have linq chain and at the end of it you want to do foreach. It looks more readable when you can add foreach at the end of chain.

[jnm2]

@hajirazin I think this would be a better solution, then: https://github.com/dotnet/csharplang/issues/101

[GSPP]

The nice thing about this is that you don't need a temporary variable if the target is a large computed expression. I have therefore written and used such an extension method. However, I found that the ugliness was not worth it.

In my opinion it is a mistake that List<T> has a ForEach method.

[hajirazin]

@jnm2 that looks better solution, but as you see for operations like Where, there are extension methods and linq syntax both. I agree in query syntax do makes more sense but in chaining syntax, extension methods looks good. You can name it as Do as well.

public void Do<TSource>(this IEnumerable<TSource> source, Action<TSource> action)
{
    foreach(var item in source)
    {
        action(item);
    }
}  

[ichensky]

After adding extention with Do method, code becomes more compact/readable

            Directory.EnumerateFiles(@"c:\tmp")
                .Where(x => !x.Contains(@".cs.")
                .Do(x => File.Move(x, x+ ".txt"));

comparing to:

            var files = Directory.EnumerateFiles(@"c:\tmp")
                .Where(x => !x.Contains(@".cs.");

            foreach (var file in files)
            {
                    File.Move(file, file + ".txt");                
            }

So, it'll be good if we add method Do to linq.

[Grauenwolf]

Something missing from this conversation is what happens after the .ForEach. Lets say I want to perform a mutation to each item in a list, then do something with that.

var updatedIds = dataSource.Where(x=> x.IsActive).ForEach(x => {
         x.IsActive = false;
         x.ClaimedBy = me;
}.Select(x => x.Id).ToList();

I can't perform this query later. Besides being inefficient, I've changed the value used by the WHERE clause. The only option with today's syntax is to create a temporary list for the Where step, then do the for-each, then go back to that temporary list to do the select.

var temp = dataSource.Where(x=> x.IsActive).ToList(); // don't forget ToList or this wont' work.

foreach ( var x in temp)
{
         x.IsActive = false;
         x.ClaimedBy = me;
}

var updatedIds = temp.Select(x => x.Id).ToList();

---

Besides being slightly more useful than a void-returning ForEach, this gives us the ability to exand our ORM support. This can easily be translated into an update-with-output SQL expression. And right now, batch updates is a major hole in ORMs such as EF.

[svick]

@Grauenwolf How would you translate that query into an SQL expression, when C# doesn't support Expression Trees with statement lambdas like the one you used? (At least not without https://github.com/dotnet/csharplang/issues/158.)

[Grauenwolf]

I'm ok with ORMs not immediately supporting it so long as there is a long term plan.

[eiriktsarpalis]

Duplicate of #40409.

Closing, for the reasons already described in that issue.

[hajirazin]

@eiriktsarpalis i think this is the older issue than the other one, and i see community giving comments and understanding the needs of it. We could achieve even .Where or .Select with foreach but .Do method is syntactical sugar and i've in many projects that people create this extension by them selfs. And if we want to support in ORM, then it should be query terminator like toList, query should be executed and forEach should be performed on that.