[C# Feature] Convenient combination of foreach and LINQ

[dsaf]

I would argue that embedded is a better term for how the syntax feels at the moment.

Currently:

foreach (var item in from xItem in new[] {"One", "Two", "Three" } 
                     where xItem == "Two"
                     select xItem)
{
    Debug.WriteLine(item);
}

Suggested:

foreach (from item in new[] {"One", "Two", "Three" } 
         where item == "Two"
         select item)
{
    Debug.WriteLine(item.ToString());
}

[HaloFour]

How about:

from item in new[] {"One", "Two", "Three" } 
where item == "Two"
foreach {
   Debug.WriteLine(item.ToString());
}

[bondsbw]

Nice suggestion @dsaf. And thank you @HaloFour, I love that syntax!

[alexpolozov]

OK, if we are opening the Pandora box of syntactic sugar now, let's not stop at the frosting level:

foreach item in new[] {"One", "Two", "Three" } 
  where item == "Two"
{
   Debug.WriteLine(item.ToString());
}

[dsaf]

Both options look like extending LINQ rather than integrating it. To me having two foreach's - with and without round brackets is weird. But to be fair your suggestions are quite close to what X++ is already using and it seems to be working: https://msdn.microsoft.com/en-us/library/aa558063.aspx

[bondsbw]

Actually @dsaf, I'd say that @apskim's approach is merely your original proposal, coupled with two syntax changes.

The first change is to remove the select item portion. I feel this is necessary anyway, because the name item is already in scope from the from clause and the select portion does nothing.

The second change removes the parentheses. This could be a change to the general case of foreach, allowing

foreach (var x in myCollection)
{
   // ...
}

to be rewritten as

foreach var x in myCollection
{
   // ...
}

I think removing the parentheses would require a braced body, otherwise perhaps the syntax would become ambiguous.

[bondsbw]

Oops, I missed that the from is removed in the shortened syntax. For that matter... why do we need the var in the existing foreach clause? That could be implicit too

foreach x in myCollection
{
    //...
}

And where (and join, orderby, let, and the rest) would just be a variation of the existing syntax

foreach x in myCollection
where x < 7
{
    //...
}

[alexpolozov]

Just to clarify: my proposal was mostly sarcastic :)
I personally think that such syntactic sugar for the sake of sugaring merely complicates the language and breaks the consistent interplay of various language constructs.

[bondsbw]

I don't think it's just for "the sake of sugaring". I feel there are clear advantage to reducing:

var filteredCollection =
    from t in myCollection
    where t < 7
    select t;

foreach (var x in filteredCollection)
{
    //...
}

to

foreach x in myCollection
where x < 7
{
    //...
}

Besides it obviously reducing the amount of code, it reduces the number of variables by removing t and filteredCollection.

Also imagine if it were more complicated (example based on MSDN LINQ samples):

var query = 
    from c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
    select new
    {
        Contact = new Contact
        {
            FirstName = c.FirstName,
            LastName = c.LastName,
        },
        Account = new Account
        {
            Address1_Telephone1 = a.Address1_Telephone1
        }
    };
foreach (var record in query)
{
    Console.WriteLine("Contact Name: {0} {1}",
        record.Contact.FirstName, record.Contact.LastName);
    Console.WriteLine("Account Phone: {0}",
        record.Account.Address1_Telephone1);
}

could become more succinctly

foreach c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
{
    Console.WriteLine("Contact Name: {0} {1}", c.FirstName, c.LastName);
    Console.WriteLine("Account Phone: {0}", a.Account.Address1_Telephone1);
}

because (in this example) it eliminates the need for temporary variables holding anonymous types.

[aluanhaddad]

@bondsbw I don't think this adds much.

The code

var filteredCollection =
    from t in myCollection
    where t < 7
    select t;

foreach (var x in filteredCollection)
{
    //...
}

Can already be shortened to:

foreach(var x in myCollection.Where(x => x < 7))
{
    //...
}

Also the code:

var query = 
    from c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
    select new
    {
        Contact = new Contact
        {
            FirstName = c.FirstName,
            LastName = c.LastName,
        },
        Account = new Account
        {
            Address1_Telephone1 = a.Address1_Telephone1
        }
    };

can already be shortened to:

var query = 
    from c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
    select new
    {
        c.FirstName,
        c.LastName,
        a.Address1_Telephone1
    };

and if you really want to avoid the anonymous type projection entirely you can write:

var query = 
    from c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
    select (Action)(()=>
    {
       Console.WriteLine("Contact Name: {0} {1}", c.FirstName, c.LastName);
       Console.WriteLine("Account Phone: {0}", a.Account.Address1_Telephone1);
    });
foreach(var a in query)
{
    a();
}

Also the proposed example:

foreach c in svcContext.ContactSet
    join a in svcContext.AccountSet
        on c.ContactId equals a.PrimaryContactId.Id
    where c.LastName == "Wilcox" || c.LastName == "Andrews"
    where a.Address1_Telephone1.Contains("(206)")
        || a.Address1_Telephone1.Contains("(425)")
{
    Console.WriteLine("Contact Name: {0} {1}", c.FirstName, c.LastName);
    Console.WriteLine("Account Phone: {0}", a.Account.Address1_Telephone1);
}

is confusing because the scoping is, at least to me, non obvious. Since c is the range variable following foreach, I would not expect a to be in scope. It would only make sense if foreach were the last clause.

Other proposals for expanding LINQ syntax, such as the one proposing the ability to specify an IEqualityComparer inline (#100) add real value.

[bondsbw]

@aluanhaddad

Since c is the range variable following foreach, I would not expect a to be in scope. It would only make sense if foreach was the last clause.

Keeping range variables in scope is, in my mind, a natural part of the proposal. I don't really see the confusion, since range variables are similarly in scope for any select including the select (Action)... workaround you mentioned.

[HaloFour]

The problem with expressing the foreach clause at the beginning of the query is that the range variables can go in and out of scope. For example:

var q = from x in Enumerable.Range(0, 10)
        select new String('X', x) into letters
        from y in letters
        select x; // compiler error, x is not in scope

Also:

var q = from x in Enumerable.Range(0, 10)
        select new String('X', x) into letters // here x is an int
        from x in letters
        select x; // here x is a char

This is why I would prefer that terminating clauses like foreach occur at the end of the query.