'Replacing nested foreach with LINQ; modify and update a property deep within

Consider the requirement to change a data member on one or more properties of an object that is 5 or 6 levels deep.

There are sub-collections that need to be iterated through to get to the property that needs inspection & modification.

Here we're calling a method that cleans the street address of a Employee. Since we're changing data within the loops, the current implementation needs a for loop to prevent the exception:

Cannot assign to "someVariable" because it is a 'foreach iteration variable'

Here's the current algorithm (obfuscated) with nested foreach and a for.

foreach (var emp in company.internalData.Emps)
{
    foreach (var addr in emp.privateData.Addresses)
    {
        int numberAddresses = addr.Items.Length;

        for (int i = 0; i < numberAddresses; i++)
        {
            //transform this street address via a static method
            if (addr.Items[i].Type =="StreetAddress")
               addr.Items[i].Text = CleanStreetAddressLine(addr.Items[i].Text);
        }
    }
}

Question: Can this algorithm be reimplemented using LINQ? The requirement is for the original collection to have its data changed by that static method call.

Update: I was thinking/leaning in the direction of a jQuery/selector type solution. I didn't specifically word this question in that way. I realize that I was over-reaching on that idea (no side-effects). Thanks to everyone! If there is such a way to perform a jQuery-like selector, please let's see it!

c++sharplinqalgorithmlinq-to-objects


Solution 1:[1]

foreach(var item in company.internalData.Emps
                        .SelectMany(emp => emp.privateData.Addresses)
                        .SelectMany(addr => addr.Items)
                        .Where(addr => addr.Type == "StreetAddress"))
     item.Text = CleanStreetAddressLine(item.Text);

Solution 2:[2]

var dirtyAddresses = company.internalData.Emps.SelectMany( x => x.privateData.Addresses )
                                              .SelectMany(y => y.Items)
                                              .Where( z => z.Type == "StreetAddress");

  foreach(var addr in dirtyAddresses)
    addr.Text = CleanStreetAddressLine(addr.Text);

Solution 3:[3]

I don't like mixing "query comprehension" syntax and dotted-method-call syntax in the same statement.

I do like the idea of separating the query from the action. These are semantically distinct, so separating them in code often makes sense.

var addrItemQuery = from emp in company.internalData.Emps
                    from addr in emp.privateData.Addresses
                    from addrItem in addr.Items
                    where addrItem.Type == "StreetAddress"
                    select addrItem;

foreach (var addrItem in addrItemQuery)
{
    addrItem.Text = CleanStreetAddressLine(addrItem.Text);
}

A few style notes about your code; these are personal, so I you may not agree:

  • In general, I avoid abbreviations (Emps, emp, addr)
  • Inconsistent names are more confusing (addr vs. Addresses): pick one and stick with it
  • The word "number" is ambigious. It can either be an identity ("Prisoner number 378 please step forward.") or a count ("the number of sheep in that field is 12."). Since we use both concepts in code a lot, it is valuable to get this clear. I use often use "index" for the first one and "count" for the second.
  • Having the type field be a string is a code smell. If you can make it an enum your code will probably be better off.

Solution 4:[4]

Dirty one-liner.

company.internalData.Emps.SelectMany(x => x.privateData.Addresses)
    .SelectMany(x => x.Items)
    .Where(x => x.Type == "StreetAddress")
    .Select(x => { x.Text = CleanStreetAddressLine(x.Text); return x; });

Solution 5:[5]

LINQ does not provide the option of having side effects. however you could do:

company.internalData.Emps.SelectMany(emp => emp.Addresses).SelectMany(addr => Addr.Items).ToList().ForEach(/*either make an anonymous method or refactor your side effect code out to a method on its own*/);

Solution 6:[6]

You can do this, but you don't really want to. Several bloggers have talked about the functional nature of Linq, and if you look at all the MS supplied Linq methods, you will find that they don't produce side effects. They produce return values, but they don't change anything else. Search for the arguments over a Linq ForEach method, and you'll get a good explanation of this concept.

With that in mind, what you probaly want is something like this:

var addressItems = company.internalData.Emps.SelectMany(
    emp => emp.privateData.Addresses.SelectMany(
           addr => addr.Items
    )
);
foreach (var item in addressItems)
{
   ...
}

However, if you do want to do exactly what you asked, then this is the direction you'll need to go:

var addressItems = company.internalData.Emps.SelectMany(
    emp => emp.privateData.Addresses.SelectMany(
           addr => addr.Items.Select(item =>
           { 
              // Do the stuff
              return item;
           }) 
    )
);

Solution 7:[7]

To update the LINQ result using FOREACH loop, I first create local ‘list’ variable and then perform the update using FOREACH Loop. The value are updated this way. Read more here:

How to update value of LINQ results using FOREACH loop

Solution 8:[8]

I cloned list and worked NET 4.7.2

List<TrendWords> ListCopy = new List<TrendWords>(sorted);

        foreach (var words in stopWords)
        {
            foreach (var item in ListCopy.Where(w => w.word == words))
            {
                item.disabled = true;
            }

        }

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 mmx
Solution 2 Stan R.
Solution 3 Community
Solution 4 Martin Jonáš
Solution 5 Rune FS
Solution 6 John Fisher
Solution 7 JeeShen Lee
Solution 8 Uzay

Related Questions