34

嗨有没有办法做这样的事情：

for (int i = 0; i < Math.Min(a.Count, b.Count); i++)
{
    // Do stuff
    //a[i]
    //b[i]
}

与 Foreach？

因为写类似的东西会很好

foreach(var item1 in list1 and var item2 in list2 /* ....*/)
{
   item1.use(item2);
}

编辑

好的，对不起，我对某些人不够清楚，所以希望有更好的解释

List<classA> listA = fillListA();
List<classB> listB = fillListB();
//here could be infinity many lists of sometimes diffrent T types

现在我想执行某种ForEach因为我不喜欢用for循环来做它应该简单明了，比如

foreach(var item1 in list1 and var item2 in list2 /* and ...*/)
{
    item1.use(item2);
}

AFAIK 我不能修改这样一个关键词类的东西，所以我认为可以像Parallel.ForEach那样构建迭代器，ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) 但是她我被卡住了，因为我不知道如何实现它

Static.ForEach<TSource>(IEnumerable<TSource>,IEnumerable<TSource>, ???Action<TSource,???>????)
4

4 回答 4

67

您可以执行foreach幕后操作，但需要使用两个枚举器：

using(var e1 = list1.GetEnumerator())
using(var e2 = list2.GetEnumerator())
{
    while(e1.MoveNext() && e2.MoveNext())
    {
         var item1 = e1.Current;
         var item2 = e2.Current;

         // use item1 and item2
    }
}

为方便起见，您可以编写如下扩展方法来执行操作：

public static void ZipDo<T1, T2>( this IEnumerable<T1> first, IEnumerable<T2> second, Action<T1, T2> action)
{
    using (var e1 = first.GetEnumerator())
    using (var e2 = second.GetEnumerator())
    {
        while (e1.MoveNext() && e2.MoveNext())
        {
            action(e1.Current, e2.Current);
        }
    }
}

并像这样使用它：

list1.ZipDo(list2, (i1,i2) => i1.Use(i2));

顺便说一句，您可以将其扩展为使用 3 个或更多列表：

public static void ZipDo<T1, T2, T3>(this IEnumerable<T1> first,
    IEnumerable<T2> second, IEnumerable<T3> third,
    Action<T1, T2, T3> action)
{
    using (var e1 = first.GetEnumerator())
    using (var e2 = second.GetEnumerator())
    using (var e3 = third.GetEnumerator())
    {
        while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
        {
            action(e1.Current, e2.Current, e3.Current);
        }
    }
}

当集合具有不同的泛型类型时，需要上述方法。但是，如果它们都具有相同的泛型类型，那么您可以编写一个采用任意数量IEnumerable<T>s 的灵活方法：

public static void ZipAll<T>(this IEnumerable<IEnumerable<T>> all, Action<IEnumerable<T>> action)
{
    var enumerators = all.Select(e => e.GetEnumerator()).ToList();
    try
    {
        while (enumerators.All(e => e.MoveNext()))
            action(enumerators.Select(e => e.Current));
    }
    finally
    {
        foreach (var e in enumerators) 
            e.Dispose();
    }
}

并使用它：

var lists = new[] {
     new[]{ 1, 1, 1 }, 
     new[]{ 2, 2, 2 }, 
     new[]{ 3, 3, 3 }};

lists.ZipAll(nums => Console.WriteLine(nums.Sum()));
// 6
// 6
// 6
于 2013-08-23T06:25:29.910 回答
29

我能想到的唯一接近的是Enumerable.Zip元组：

foreach(var tuple in list1.Zip(list2, Tuple.Create))
{
    tuple.Item1.use(tuple.Item2);
}

当然，如果不是use，我们有一个非副作用的方法，它从两个元素中产生第三个值，你可以这样做：

var result = list1.Zip(list2, (item1, item2) => item1.ProduceObject(item2))
                  .ToList(); // if required
于 2013-08-23T06:14:58.237 回答
4

您可以使用类似这样的Zip方法（尽管仅在 .net 4 及更高版本中可用）？

List<int> l4 = new List<int> { 1, 2, 3, 4 };
List<int> l5 = new List<int> { 5, 6, 7 };

var l4Andl5 = l4.Zip(l5, (l, m) => new { List1 = l, List2 = m });
foreach (var x in l4Andl5)
{


}
于 2013-08-23T06:22:10.220 回答
3

如果列表长度相同，您也可以简单地使用局部整数变量：

List<classA> listA = fillListA();
List<classB> listB = fillListB();

var i = 0;
foreach(var itemA in listA)
{
    itemA.use(listB[i++]);
}
于 2016-01-19T18:57:34.840 回答