Iterate over two collections of equal length

Question

What's the best way to iterate over two collections of equal length?

Currently I'm using this:

for(var index = 0; index < collection1.Count(); index++)
{
    var item1 = collection1[index];
    var item2 = collection2[index];
    Console.WriteLine(item1.ToString() + ", "+ item2.ToString());
}

But I'd love to be able to use a foreach instead, e.g.

foreach(item1, item2 in collection1, collection2)
{
    Console.WriteLine(item1.ToString() + ", " + item2.ToString();
}

Now, this would be sort of possible if I zipped my two collections into a dictionary, but is that the best way to go? Would that be a sufficient gain of readability while sacrificing the performance needed to build the dictionary?

Similarly, I'm not sure if a dictionary is idealistically correct here, as there may not necessarily be a link between the two collections (other than their order in the list), merely a guarantee that they both have the same length.

Answer 1

You can use LINQ's Zip method. As usual, it's a bit slower than manually written code, but unless this is in a hot spot it rarely matters. The cost of Console.WriteLine vastly exceeds the cost of LINQ.

foreach(var pair in collection1.Zip(collection2, Tuple.Create))
{
    Console.WriteLine("{0}, {1}", pair.Item1, pair.Item2);
}

---

You can replace Tuple.Create by ValueTuple.Create if you target .net 4.7 or you referenced the compatibility nuget package. This saves a heap allocation and is usually faster.

In C# 7 you could use named tuples, which enables meaningful property names. It's based on ValueTuple and thus avoid the heap allocation as well.

names.Zip(ages, (name, age) => (Name:name, Age:age))

Answer 2

The first one will always be more readable. If you want to start building collections that contain your previous collections, you'll add another layer of abstraction to your code for no reason: this will hurt readability a lot.

One of the limitations of the foreach loop is that it can only iterate one collection at a time. Working around this might seem interesting but I doubt there will be any solution that's more readable.

Answer 3

Another alternative:

using (var enumerator1 = collection1.GetEnumerator())
using (var enumerator2 = collection2.GetEnumerator()) {
    while(enumerator1.MoveNext() && enumerator2.MoveNext()) {
      Console.WriteLine(enumerator1.Current.ToString() + ", " + enumerator1.Current.ToString());
    }
}

Answer 4

What's the best way to iterate over two collections of equal length?

Don't. This is often (but not always) an indication that the two collections should instead be one, of some compound type.

For example, if the collections represent 2D points, with the first one containing X coordinates and the second one Y coordinates, you should instead create a new Point type and have a collection of those.