I have a method with a nested foreach collection (iterate a set of objects and then look inside each object). I saw in a book a good pattern to make this much more elegant but cannot remember/find the code example. How else could I make this more tidy?
The code is just a typical nested foreach statement so I have not provided a code sample.
The obvious solution is to flatten into methods.
Old:
void SubmitOrders()
{
var orders = GetOrders();
foreach (Order o in orders)
{
foreach (OrderDetail d in o.Details)
{
// Blah...
}
}
}
New:
void SubmitOrders()
{
var orders = GetOrders()
foreach (Order o in orders)
{
SubmitOrder(o);
}
}
void SubmitOrder(Order order)
{
foreach (OrderDetail d in order.Details)
{
// Blah...
}
}
Other answers here seem to be focused on Linq, and I would agree that if your loops have no side-effects (i.e. you are just trying to extract some information from the innermost loop), then you can probably rewrite the entire thing using one or two simple Linq statements. If side-effects are involved, then just follow the time-tested practice of subroutines.
You're going to have to be more specific about what you mean regarding "more elegant", as IMO there's nothing particularly inelegant about a nested foreach.
That being said, the LINQ extension methods in .NET 3.5 and above can help out (specifically SelectMany).
public class Foo
{
public List<string> Strings { get; set; }
}
...
List<Foo> foos = new List<Foo>();
foreach(string str in foos.SelectMany(f => f.Strings))
{
...
}
Before:
foreach(Customer c in Customers)
{
foreach(Order o in c.Orders)
{
o.Dance();
}
}
After:
foreach(Order o in Customers.SelectMany(c => c.Orders))
{
o.Dance();
}
You could use the LINQ SelectMany operator:
foreach (var bar in model.FooCollection.SelectMany(f => f.Bars))
{
// Do Stuff
}
Its difficult to give an answer without any context or code snippet. However, Martin Fowler has a really good article on refactoring loops into LINQ pipelines which can be found here (appreciate this is an old question though, so hopefully future readers will benefit!).
I'd suggest creating a Dictionary out of the second thing you loop through. Then inside the foreach just use your Dictionary as a lookup for the value you want.
Updated with examples embedded foreach and Dictionary alternative:
List<ItemA> itemAs = new List<ItemA> {
new ItemA { id = 1, number = 10 },
new ItemA { id = 2, number = 15 },
new ItemA { id = 3, number = 20 }
};
List<ItemB> itemBs = new List<ItemB> {
new ItemB { id = 1, rate = 100 },
new ItemB { id = 2, rate = 150 },
new ItemB { id = 3, rate = 200}
};
List<ItemAB> itemABs = new List<ItemAB>();
// embedded foreach
foreach(ItemA itemA in itemAs)
{
foreach(ItemB itemB in itemBs)
{
if(itemA.id == itemB.id)
{
ItemAB itemAB = new ItemAB { id = itemA.id, number = itemA.number, rate = itemB.rate };
itemABs.Add(itemAB);
}
}
}
// using dictionary as lookup
Dictionary<int, ItemB> itemBLookup = itemBs.ToDictionary(x => x.id, y => y);
foreach (ItemA itemA in itemAs)
{
itemBLookup.TryGetValue(itemA.id, out ItemB itemB);
ItemAB itemAB = new ItemAB { id = itemA.id, number = itemA.number, rate = itemB.rate };
itemABs.Add(itemAB);
}
Are you thinking of something like this?
public class YourObject{
public List<OtherObject> Others { get; set; }
}
public class OtherObject{
public void DoIt(){}
}
var theList = new List<YourObject>();
theList.ForEach(yo => yo.Others.ForEach(oo => oo.DoIt()));
ForEach is a method on List<T>, not LINQ.
ForEach extension method on IEnumerable<T> that works exactly like it does for List<T>.