如何从C#中的两个列表中创建单个对象对列表？

我有两个对象列表。列表A和列表B。我需要创建列表C，它将列表A和列表B组合成一对。例如：

List A
object a1
object a2
object a3

List B
object b1
object b2
object b3

List C (creates pairs)
object c1 (object a1, object b1)
object c2 (object a2, object b2)
object c3 (object a3, object b3)

您可以使用System.Linq中的方法

IEnumerable<Tuple<A, B>> pairs = listA.Zip(listB, (a, b) => Tuple.Create(a, b));

IEnumerable pairs=listA.Zip（listB，（a，b）=>Tuple.Create（a，b））；

使用此结果可枚举的示例：

foreach (Tuple<A, B> pair in pairs)
{
    A a = pair.Item1;
    B b = pair.Item2;
}

foreach（成对的元组对）
{
A=对。项目1；
B=配对项目2；
}

遗憾的是，在.NET中没有一个重载可以自动执行tupleation。这样的扩展将如下所示：

public static IEnumerable<Tuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)
{
    return first.Zip(second, Tuple.Create);
}

 var listA = new object[] { "1", "2", "3" };
 var listB = new object[] { "a", "b", "c" };
 var listC = Enumerable.Zip(listA,listB, (x,y)=>new {x,y});

 foreach (var item in listC)
 {
    Console.WriteLine("{0},{1}", item.x,item.y);
 }

公共静态IEnumerable Zip（此IEnumerable第一，IEnumerable第二）
{
返回第一个.Zip（第二个，Tuple.Create）；
}

这意味着您可以编写如下代码：

IEnumerable<Tuple<A, B>> pairs = listA.Zip(listB);

IEnumerable pairs=listA.Zip（listB）；

---

注意：另一种选择是创建匿名类型，而不是创建Tuple，但这种方法的缺点是，由于类型没有名称，您无法（有效地）将结果IEnumerable从创建它的方法中传递出去。

我建议使用Tuple列表

.

这样就可以了：

public static IEnumerable<Tuple<T, U>> CombineWith<T, U>(this IEnumerable<T> first, IEnumerable<U> second)
{
    using (var firstEnumerator = first.GetEnumerator())
    using (var secondEnumerator = second.GetEnumerator())
    {
        bool hasFirst = true;
        bool hasSecond = true;

        while (
            // Only call MoveNext if it didn't fail last time.
            (hasFirst && (hasFirst = firstEnumerator.MoveNext()))
            | // WARNING: Do NOT change to ||.
            (hasSecond && (hasSecond = secondEnumerator.MoveNext()))
            )
        {
            yield return Tuple.Create(
                    hasFirst ? firstEnumerator.Current : default(T),
                    hasSecond ? secondEnumerator.Current : default(U)
                );
        }
    }
}

公共静态IEnumerable组合（此IEnumerable第一，IEnumerable第二）
{
使用（var firstEnumerator=first.GetEnumerator（））
使用（var secondEnumerator=second.GetEnumerator（））
{
bool hasFirst=true；
bool-hassond=true；
当(
//只有上次没有失败时才调用MoveNext。
（hasFirst&（hasFirst=firstEnumerator.MoveNext（））
|//警告：不要更改为| |。
（HassSecond&（HassSecond=secondEnumerator.MoveNext（））
)
{
产生返回元组(
hasFirst？firstEnumerator。当前：默认值（T），
HassSecond？Second枚举数。当前：默认值（U）
);
}
}
}

编辑：我非常喜欢这个答案。

类似这样：

public static IEnumerable<Tuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)
{
    return first.Zip(second, Tuple.Create);
}

 var listA = new object[] { "1", "2", "3" };
 var listB = new object[] { "a", "b", "c" };
 var listC = Enumerable.Zip(listA,listB, (x,y)=>new {x,y});

 foreach (var item in listC)
 {
    Console.WriteLine("{0},{1}", item.x,item.y);
 }

输出： 1、a 2，b 3，c

.NETCore3有一个。它接受两个IEnumerable并创建一个包含值元组的IEnumerable，其中包含来自两个输入IEnumerable的元素

IEnumerable<(A a, B b)> pairs = listA.Zip(listB);

---

使用

System.Linq

Enumerable.Zip

方法（不指定函数参数

Func

）的潜在解决方案如下（注意，我使用ints提供了一个简单的具体示例）：

---

请参阅此链接（请参阅此msdn链接以了解更多详细信息：比我的解决方案好得多：）。谢谢，这是一个很好的建议-但是，这似乎仅在Framework 4.0中可用。不幸的是，我在这个项目上的权限仅限于3.5。@Earl，在这种情况下，根据Jonathan Dickinson的回答，您必须手动获取

枚举器并进行迭代。*注意，2018年您现在可以执行：
listA.Zip（listB，（a，b）=>Tuple.Create）
如果我能够使用4.0框架，我会使用Paul的解决方案，但这在3.5上有效，所以谢谢@Earl这在3.5上是如何工作的<代码>元组

是。

foreach(var pair in pairs)
{
    A a = pair.a;
    B b = pair.b;
}

List<int> list1 = new List<int>() {1,2,3,4,5};
List<int> list2 = new List<int>() {5,4,3,2,1};

IEnumerable<(int, int)> pairs;
pairs = list1.Zip(list2);
Console.WriteLine(string.Join(", ", pairs));

(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)