我在解析文本文件时构建了两个数组。第一个包含列名，第二个包含当前行的值。我需要一次遍历两个列表来构建 map 。现在我有以下内容:

var currentValues = currentRow.Split(separatorChar);
var valueEnumerator = currentValues.GetEnumerator();

foreach (String column in columnList)
{
    valueEnumerator.MoveNext();
    valueMap.Add(column, (String)valueEnumerator.Current);
}

这工作得很好，但它并不能完全满足我的优雅感，而且如果数组的数量大于两个(我偶尔不得不这样做)，它会变得非常毛茸茸。有没有人有另一个更简洁的成语？

最佳答案

您的初始代码中有一个不明显的伪错误 - IEnumerator<T>延伸IDisposable所以你应该处理它。这对于迭代器 block 可能非常重要!数组不是问题，但其他 IEnumerable<T> 会是问题实现。

我会这样做:

public static IEnumerable<TResult> PairUp<TFirst,TSecond,TResult>
    (this IEnumerable<TFirst> source, IEnumerable<TSecond> secondSequence,
     Func<TFirst,TSecond,TResult> projection)
{
    using (IEnumerator<TSecond> secondIter = secondSequence.GetEnumerator())
    {
        foreach (TFirst first in source)
        {
            if (!secondIter.MoveNext())
            {
                throw new ArgumentException
                    ("First sequence longer than second");
            }
            yield return projection(first, secondIter.Current);
        }
        if (secondIter.MoveNext())
        {
            throw new ArgumentException
                ("Second sequence longer than first");
        }
    }        
}

然后您可以在需要时重用它:

foreach (var pair in columnList.PairUp(currentRow.Split(separatorChar),
             (column, value) => new { column, value })
{
    // Do something
}

或者，您可以创建一个通用的 Pair 类型，并删除 PairUp 方法中的投影参数。

编辑:

对于 Pair 类型，调用代码如下所示:

foreach (var pair in columnList.PairUp(currentRow.Split(separatorChar))
{
    // column = pair.First, value = pair.Second
}

这看起来很简单。是的，您需要将实用程序方法放在某个地方，作为可重用代码。在我看来这几乎不是问题。现在对于多个数组...

如果数组的类型不同，我们就有问题了。你不能在泛型方法/类型声明中表达任意数量的类型参数——你可以为任意数量的类型参数编写 PairUp 版本，就像有Action一样。和 Func委托(delegate)最多 4 个委托(delegate)参数 - 但你不能随意设置。

但是，如果所有值都是同一类型 - 如果您乐于坚持使用数组 - 这很容易。 (非数组也可以，但您不能提前进行长度检查。)您可以这样做:

public static IEnumerable<T[]> Zip<T>(params T[][] sources)
{
    // (Insert error checking code here for null or empty sources parameter)

    int length = sources[0].Length;
    if (!sources.All(array => array.Length == length))
    {
        throw new ArgumentException("Arrays must all be of the same length");
    }

    for (int i=0; i < length; i++)
    {
        // Could do this bit with LINQ if you wanted
        T[] result = new T[sources.Length];
        for (int j=0; j < result.Length; j++)
        {
             result[j] = sources[j][i];
        }
        yield return result;
    }
}

那么调用代码将是:

foreach (var array in Zip(columns, row, whatevers))
{
    // column = array[0]
    // value = array[1]
    // whatever = array[2]
}

当然，这涉及到一定数量的复制——您每次都在创建一个数组。你可以通过引入另一种类型来改变它:

public struct Snapshot<T>
{
    readonly T[][] sources;
    readonly int index;

    public Snapshot(T[][] sources, int index)
    {
        this.sources = sources;
        this.index = index;
    }

    public T this[int element]
    {
        return sources[element][index];
    }
}

虽然这可能被大多数人认为是矫枉过正 ;)

老实说，我可以不断想出各种各样的点子……但最基本的是:

• 通过一些可重用的工作，您可以使调用代码更好
• 对于类型的任意组合，由于泛型的工作方式，您必须分别处理每个参数数量(2、3、4 ...)
• 如果您乐于为每个部分使用相同的类型，您可以做得更好

关于c# - 如何一次遍历两个数组？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/496704/