Wie kombiniere ich mehr als zwei generische Listen in C # Zip?

Habe ich drei (es ist möglich, mehr als 3-4 generische Liste, aber in diesem Beispiel wollen wir 3) generische Listen.

List<string> list1

List<string> list2

List<string> list3

alle Listen haben gleich viele Elemente (gleiche gilt).

Verwendet, dass ich zum kombinieren von zwei Listen mit REIßVERSCHLUSS :

var result = list1.Zip(list2, (a, b) => new {
  test1 = f,
  test2 = b
}

Verwendet, dass ich für foreach - Anweisung, um zu vermeiden foreach jede Liste, wie

foreach(var item in result){
Console.WriteLine(item.test1 + " " + item.test2);
}

Wie zu verwenden simmilary mit Reißverschluss für drei Listen ?

Dank

EDIT:

Ich möchte gerne:

List<string> list1 = new List<string>{"test", "otherTest"};

List<string> list2 = new List<string>{"item", "otherItem"};

List<string> list3 = new List<string>{"value", "otherValue"};

nach ZIP (ich weiß nicht, Methode), möchte ich das Ergebnis (in VS2010 debug-Modus)

[0] { a = {"test"},
      b = {"item"},
      c = {"value"}
    }   

[1] { a = {"otherTest"},
      b = {"otherItem"},
      c = {"otherValue"}
    }

Wie zu tun ?

InformationsquelleAutor der Frage Snake Eyes | 2012-04-24

Der offensichtlichste Weg für mich wäre, die Nutzung Zip zweimal.

Beispielsweise

var results = l1.Zip(l2, (x, y) => x + y).Zip(l3, (x, y) => x + y);

kombinieren würde (add), die Elemente der drei List<int> Objekte.

Update:

Könnten Sie eine neue Erweiterung Methode, die wirkt wie ein Zip mit drei IEnumerables, etwa so:

public static class MyFunkyExtensions
{
    public static IEnumerable<TResult> ZipThree<T1, T2, T3, TResult>(
        this IEnumerable<T1> source,
        IEnumerable<T2> second,
        IEnumerable<T3> third,
        Func<T1, T2, T3, TResult> func)
    {
        using (var e1 = source.GetEnumerator())
        using (var e2 = second.GetEnumerator())
        using (var e3 = third.GetEnumerator())
        {
            while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
                yield return func(e1.Current, e2.Current, e3.Current);
        }
    }
}

Die Nutzung (in den gleichen Kontext wie oben) wird jetzt:

var results = l1.ZipThree(l2, l3, (x, y, z) => x + y + z);

Ähnlich, Sie drei Listen können nun kombiniert werden mit:

var results = list1.ZipThree(list2, list3, (a, b, c) => new { a, b, c });

InformationsquelleAutor der Antwort GolfWolf

class Program
{
    static void Main(string[] args)
    {
        List<string> list1 = new List<string> { "test", "otherTest" };
        List<string> list2 = new List<string> { "item", "otherItem" };
        List<string> list3 = new List<string> { "value", "otherValue" };

        var result = CombineListsByLayers(list1, list2, list3);
    }

    public static List<string>[] CombineListsByLayers(params List<string>[] sourceLists)
    {
        var results = new List<string>[sourceLists[0].Count];

        for (var i = 0; i < results.Length; i++)
        {
            results[i] = new List<string>();
            foreach (var sourceList in sourceLists)
                results[i].Add(sourceList[i]);
        }
        return results;
    }

InformationsquelleAutor der Antwort G.Y

Kombinieren Sie viele Listen in C# mit cascade zip Methoden und anonyme Klassen und Tupel Ergebnis.

List<string> list1 = new List<string> { "test", "otherTest" };
List<string> list2 = new List<string> { "item", "otherItem" };
List<string> list3 = new List<string> { "value", "otherValue" };

IEnumerable<Tuple<string, string, string>> result = list1
    .Zip(list2, (e1, e2) => new {e1, e2})
    .Zip(list3, (z1, e3) => Tuple.Create(z1.e1, z1.e2, e3));

Ist das Ergebnis:

[0]
{(test, item, value)}
    Item1: "test"
    Item2: "item"
    Item3: "value"

InformationsquelleAutor der Antwort andrew.fox

2

Gibt es eine Recht interessante Lösung, die ich bin mir dessen bewusst. Es ist interessant, meist aus Pädagogischer Perspektive, aber wenn man ausführen muss, zippen und verschiedenen Grafen von Listen VIEL, dann wird es auch nützlich sein.

Diese Methode überschreibt .NET LINQ SelectMany Funktion, die durch eine Konvention, wenn Sie die LINQ - Abfrage-syntax. Die standard - SelectMany Umsetzung tut ein Kartesisches Produkt. Die overrided man tun kann, flitzen statt. Die tatsächliche Umsetzung könnte sein:
```
static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source,
        Func<TSource, IEnumerable<TCollection>> selector, Func<TSource, TCollection, TResult> select)
{
    using (var e1 = source.GetEnumerator())
        using (var e2 = selector(default(TSource)).GetEnumerator())
            while (true)
                if (e1.MoveNext() && e2.MoveNext())
                    yield return select(e1.Current, e2.Current);
                else
                    yield break;
}
```
Sieht es ein bisschen beängstigend, aber es ist eine Logik packen die, wenn Sie einmal geschrieben ist, kann an vielen Orten verwendet werden und der client code sieht ziemlich nett - Sie können zip beliebige Anzahl von IEnumerable<T> mit standard-LINQ-Abfrage-syntax:
```
var titles = new string[] { "Analyst", "Consultant", "Supervisor"};
var names = new string[] { "Adam", "Eve", "Michelle" };
var surnames = new string[] { "First", "Second", "Third" };

var results =
    from title in titles
    from name in names
    from surname in surnames
    select $"{ title } { name } { surname }";
```
Wenn Sie dann ausführen:
```
foreach (var result in results)
    Console.WriteLine(result);
```
Erhalten Sie:
```
Analyst Adam First
Consultant Eve Second
Supervisor Michelle Third
```
Halten, sollten Sie diese Erweiterung private innerhalb Ihrer Klasse, denn sonst wird sich radikal ändern, das Verhalten der Sie umgebenden code. Auch eine neue Art nützlich sein wird, so dass es nicht colide mit standard-LINQ-Verhalten für IEnumerables.

Für pädagogische Zwecke habe ich mal eine kleine c# - Projekt mit dieser Erweiterung Methode + paar Vorteile: https://github.com/lukiasz/Zippable

Auch, wenn Sie das interessant finden, empfehle ich Jon Skeet ist Reimplementing LINQ to Objects Artikel.

Spaß haben!

InformationsquelleAutor der Antwort lukiasz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.