Как выполнить итерации через два IEnumerables одновременно?

Вы можете сделать что-то подобное.

IEnumerator enuma = a.GetEnumerator();
IEnumerator enumb = b.GetEnumerator();
while (enuma.MoveNext() && enumb.MoveNext())
{
    string vala = enuma.Current as string;
    string valb = enumb.Current as string;
}

В C # нет foreach, который мог бы делать это так, как вы хотите (о чем я знаю).

В .NET 4 вы можете использовать метод расширения .Zip для IEnumerable

IEnumerable<int> list1 = Enumerable.Range(0, 100);
IEnumerable<int> list2 = Enumerable.Range(100, 100);

foreach (var item in list1.Zip(list2, (a, b) => new { a, b }))
{
    // use item.a and item.b
}

, однако он не будет создавать неравные длины. Однако вы всегда можете это проверить.

Используйте функцию Zip , например

foreach (var entry in list1.Zip(list2, (a,b)=>new {First=a, Second=b}) {
    // use entry.First und entry.Second
}

Это не вызывает исключения, хотя ...

Короче говоря, язык не предлагает чистого способа сделать это. Перечисление было разработано таким образом, чтобы выполнять перечисление по одному за раз. Вы можете довольно легко имитировать то, что делает для вас foreach:

using(IEnumerator<A> list1enum = list1.GetEnumerator())
using(IEnumerator<B> list2enum = list2.GetEnumerator())    
while(list1enum.MoveNext() && list2enum.MoveNext()) {
        // list1enum.Current and list2enum.Current point to each current item
    }

Что делать, если они имеют разную длину, решать вам. Возможно, выясните, какие из них остались после завершения цикла while, и продолжайте работать с этим, выбросите исключение, если они должны быть одинаковой длины и т. Д.

Используйте IEnumerable.GetEnumerator, чтобы вы могли перемещаться по перечисляемому. Обратите внимание, что это может иметь действительно неприятное поведение, и вы должны быть осторожны. Если вы хотите, чтобы он работал, используйте это, если вы хотите иметь поддерживаемый код, используйте два foreach.

Вы можете создать класс-оболочку или использовать библиотеку (как предлагает Джон Скит) для обработки этой функциональности более общим способом, если вы собираетесь использовать ее более одного раза в своем коде.

Код того, что я предлагаю:

var firstEnum = aIEnumerable.GetEnumerator();
var secondEnum = bIEnumerable.GetEnumerator();

var firstEnumMoreItems = firstEnum.MoveNext();
var secondEnumMoreItems = secondEnum.MoveNext();    

while (firstEnumMoreItems && secondEnumMoreItems)
{
      // Do whatever.  
      firstEnumMoreItems = firstEnum.MoveNext();
      secondEnumMoreItems = secondEnum.MoveNext();   
}

if (firstEnumMoreItems || secondEnumMoreItems)
{
     Throw new Exception("One Enum is bigger");
}

// IEnumerator does not have a Dispose method, but IEnumerator<T> has.
if (firstEnum is IDisposable) { ((IDisposable)firstEnum).Dispose(); }
if (secondEnum is IDisposable) { ((IDisposable)secondEnum).Dispose(); }

Вы хотите что-то вроде оператора LINQ Zip , но версия в .NET 4 всегда просто обрезает после завершения любой последовательности.

Реализация MoreLINQ имеет метод EquiZip , который вместо этого генерирует исключение InvalidOperationException .

var zipped = list1.EquiZip(list2, (a, b) => new { a, b });

foreach (var element in zipped)
{
    // use element.a and element.b
}

using(var enum1 = list1.GetEnumerator())
using(var enum2 = list2.GetEnumerator())
{
    while(true)
    {
        bool moveNext1 = enum1.MoveNext();
        bool moveNext2 = enum2.MoveNext();
        if (moveNext1 != moveNext2)
            throw new InvalidOperationException();
        if (!moveNext1)
            break;
        var a = enum1.Current;
        var b = enum2.Current;
        // use a and b
    }
}