Come creare un singolo elenco di coppie di oggetti da due elenchi in C#?

Question

Ho due elenchi di oggetti. Elenco A e Elenco B. Devo creare la lista C che combina l'elenco A e l'elenco B in coppie. Ad esempio:

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) 

Answer 1

Questo lo farebbe:

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) 
       ); 
     } 
    } 
} 

Edit: Io preferisco di gran lunga Paul's risposta.

Answer 2

È possibile utilizzare il metodo Enumerable.Zip() in System.Linq.

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

Esempio utilizza questo risultante enumerable:

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

peccato non c'è un sovraccarico che automatizza il tupleation NET. Tale estensione sarebbe simile a questa:

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

Il che significa che si può quindi scrivere codice simile:

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

Nota: Un'altra opzione potrebbe essere quella di creare tipi anonimi, invece di Tuple ma il rovescio della medaglia a questo approccio è che non sarebbe possibile (utilmente) passare l'IEnumerable risultante dal metodo che è stato creato, a causa del tipo che non ha un nome.

Answer 3

Quando dici "Coppie" intendi coppie chiave/valore?

Se è così, si desidera utilizzare Dictionary<object, object>

Answer 4

Vorrei suggerire di utilizzare un elenco di tupples

http://msdn.microsoft.com/en-us/library/system.tuple.aspx.

Answer 5

Qualcosa di simile a questo:

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); 
} 

uscita: 1, un 2, b 3, c