如何在.NET2中同时迭代两个IEnumerable

编辑：我将此问题分为两个问题：

• 迭代两个以较短列表结尾的列表
• 迭代多个列表，直到到达最长列表的最后一个元素

假设我有两个包含许多元素的IEnumerable。每个IEnumerable都有另一个类型T

IEnumerable<int> ints=getManyInts();
IEnumerable<string> strings=getSomeStrings();

IEnumerable ints=getManyInts（）；
IEnumerable strings=GetSomeString（）；

我要做的是迭代两个列表，并为每个步骤获取一个包含一个int和一个字符串的项，直到到达最短列表的末尾

for(Item<int,string> item in Foo.Combine<int,string>(ints, strings))
{
    int i=item.Val1;
    string s=item.Val2;
}

for（Foo.Combine中的项（整数、字符串））
{
int i=第1项；
字符串s=item.Val2；
}

您还可以给我一个在.NET 4中如何执行此操作的提示。

对.NET 4.0的提示：

var result = ints.Zip(strings, (i, s) => new { Key = i, Value = s });
foreach(var item in result)
{
    int key = item.Key;
    string value = item.Value;
    // Do something with the kvp
}

作为非LINQ apprach（.NET 2），这可以像这样进行顶部迭代，直到其中一个枚举完成：

using (IEnumerator<int> intItem = GetManyInts().GetEnumerator())
using (IEnumerator<string> stringItem = GetSomeStrings().GetEnumerator()) {
  while (intItem.MoveNext() && stringItem.MoveNext()) {
    int i=intItem.Current;
    string s=stringItem.Current;
  }
}

使用（IEnumerator intItem=GetManyInts（）.GetEnumerator（））
使用（IEnumerator stringItem=GetSomeString（）.GetEnumerator（））{
while（intItem.MoveNext（）&&stringItem.MoveNext（））{
int i=初始项电流；
字符串s=stringItem.Current；
}
}

编辑（对于新条件），使用默认值进行迭代，直到完成最后一次枚举：

using (IEnumerator<int> intItem = GetManyInts().GetEnumerator())
using (IEnumerator<string> stringItem = GetSomeStrings().GetEnumerator()) {
  bool hasInt;
  bool hasString;
  while ((hasInt = intItem.MoveNext()) | (hasString = stringItem.MoveNext())) {
    int i=hasInt ? intItem.Current : default(int);
    string s=hasString ? stringItem.Current : default(string);
  }
}

使用（IEnumerator intItem=GetManyInts（）.GetEnumerator（））
使用（IEnumerator stringItem=GetSomeString（）.GetEnumerator（））{
布尔·哈辛特；
布尔·哈斯特林；
而（（hasInt=intItem.MoveNext（））|（hastring=stringItem.MoveNext（））{
int i=hasInt？初始项当前：默认值（int）；
字符串s=HaString？stringItem.Current：默认值（字符串）；
}
}

这可以通过手动执行for-each循环在内部执行的操作来完成

IEnumerable ints=getManyInts（）；
IEnumerable strings=GetSomeString（）；
使用（IEnumerator intsEnum=ints.GetEnumerator（））
使用（IEnumerator stringsEnum=strings.GetEnumerator（））
{
while（intsEnum.MoveNext（）&&stringsEnum.MoveNext（））
{
int i=内部电流；
字符串s=stringsEnum.Current；
}
}

编辑最长列表：

IEnumerable<int> ints=getManyInts();
IEnumerable<string> strings=getSomeStrings();
using (IEnumerator<int> intsEnum = ints.GetEnumerator())
using (IEnumerator<string> stringsEnum = strings.GetEnumerator())
{
    bool intIsValid = intsEnum.MoveNext()
    bool stringIsValid = stringsEnum.MoveNext()
    while (intIsValid || stringIsValid)
    {
        int i = default(int)
        string s = default(string)
        if(intIsValid)
        {
           i = intsEnum.Current;
           intIsValid = intsEnum.MoveNext();
        }
        if(stringIsValid)
        {
           s = stringsEnum.Current;
           stringIsValid = stringsEnum.MoveNext();
        }
        //code goes here
    }
}

IEnumerable ints=getManyInts（）；
IEnumerable strings=GetSomeString（）；
使用（IEnumerator intsEnum=ints.GetEnumerator（））
使用（IEnumerator stringsEnum=strings.GetEnumerator（））
{
bool intIsValid=intsEnum.MoveNext（）
bool stringIsValid=stringsEnum.MoveNext（）
while（intIsValid | | stringIsValid）
{
int i=默认值（int）
字符串s=默认值（字符串）
如果（intIsValid）
{
i=内部电流；
intIsValid=intsEnum.MoveNext（）；
}
if（stringIsValid）
{
s=串电流；
stringIsValid=stringsEnum.MoveNext（）；
}
//代码在这里
}
}

我不确定我是否理解这个问题/上下文

使用字典对你有用吗

internal static class Foo
    {
        internal static Dictionary<TKey, TValue> Combine<TKey, TValue>
            ( IList<TKey> keys, IList<TValue> values )
        {
            var dictionary = new Dictionary<TKey, TValue>();
            // write your own 'combination' code...
            for (int i = 0; i < keys.Count && i<values.Count; i++)
            {
                dictionary.Add(keys[i], values[i]);
            }
            return dictionary;
        }
    }

    private static void Main(string[] args)
    {
        // collection initialization and var: .NET 3.0 or higher
        var keys = new List<int> {1, 2, 3, 5, 6, 7, 8, 10, 15, 99};
        var values = new List<string> {"one", "two", "tree", "four"};

        var combinded = Foo.Combine<int, string>(keys, values);
        foreach (KeyValuePair<int, string> keyValuePair in combinded)
        {
            int key = keyValuePair.Key;
            string value = keyValuePair.Value;
        }
    }

内部静态类Foo
{
内部静态字典组合
（IList键，IList值）
{
var dictionary=newdictionary（）；
//编写自己的“组合”代码。。。
对于（int i=0；i只回答短（.NET 4）部分被认为是懒惰；-）@TToni，我是开发人员，顾名思义，我很懒：-）谢谢。我知道在.NET 4中这一定很容易。但不幸的是，我还必须维护一些旧项目。我认为只给出.NET 4代码是安全的，因为大多数人似乎只给出.NET 2代码。字典会弄乱顺序，并且会因为密钥的重复而失败。不，李sts非常长（从DB生成或从DB生成）。我不想在内存中保留所有项。您的答案中有一个逻辑错误：| |运算符将跳过下一步的第二步
internal static class Foo
    {
        internal static Dictionary<TKey, TValue> Combine<TKey, TValue>
            ( IList<TKey> keys, IList<TValue> values )
        {
            var dictionary = new Dictionary<TKey, TValue>();
            // write your own 'combination' code...
            for (int i = 0; i < keys.Count && i<values.Count; i++)
            {
                dictionary.Add(keys[i], values[i]);
            }
            return dictionary;
        }
    }

    private static void Main(string[] args)
    {
        // collection initialization and var: .NET 3.0 or higher
        var keys = new List<int> {1, 2, 3, 5, 6, 7, 8, 10, 15, 99};
        var values = new List<string> {"one", "two", "tree", "four"};

        var combinded = Foo.Combine<int, string>(keys, values);
        foreach (KeyValuePair<int, string> keyValuePair in combinded)
        {
            int key = keyValuePair.Key;
            string value = keyValuePair.Value;
        }
    }