Wie nehmen die jeweils zwei Elemente von IEnumerable als paar?

Einen faulen Erweiterung Methode, dies zu erreichen ist:

public static IEnumerable<Tuple<T, T>> Tupelize<T>(this IEnumerable<T> source)
{
    using (var enumerator = source.GetEnumerator())
        while (enumerator.MoveNext())
        {
            var item1 = enumerator.Current;

            if (!enumerator.MoveNext())
                throw new ArgumentException();

            var item2 = enumerator.Current;

            yield return new Tuple<T, T>(item1, item2);
        }
}

Beachten Sie, dass, wenn die Anzahl der Elemente geschieht, um nicht auch diese zu werfen. Ein anderer Weg wäre die Verwendung dieser extensions-Methode split der Quell-Sammlung in chunks von 2:

public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> list, int batchSize)
{

    var batch = new List<T>(batchSize);

    foreach (var item in list)
    {
        batch.Add(item);
        if (batch.Count == batchSize)
        {
            yield return batch;
            batch = new List<T>(batchSize);
        }
    }

    if (batch.Count > 0)
        yield return batch;
}

Dann können Sie tun:

var tuples = items.Chunk(2)
    .Select(x => new Tuple<string, string>(x.First(), x.Skip(1).First()))
    .ToArray();

Schließlich verwenden nur bestehende extension Methoden:

var tuples = items.Where((x, i) => i % 2 == 0)
    .Zip(items.Where((x, i) => i % 2 == 1), 
                     (a, b) => new Tuple<string, string>(a, b))
    .ToArray();

InformationsquelleAutor eulerfx

Können Sie diese Arbeit mithilfe der LINQ - .Zip() extension Methode:

IEnumerable<string> source = new List<string> { "First", "1", "Second", "2" };
var tupleList = source.Zip(source.Skip(1), 
                           (a, b) => new Tuple<string, string>(a, b))
                      .Where((x, i) => i % 2 == 0)
                      .ToList();

Grundsätzlich der Ansatz ist, flitzen die Quelle Enumerable mit sich selbst, wobei das erste element, also die zweite enumeration ist eine off - geben Sie den Paaren ("Erste, "1"), ("1", "Zweite"), ("Zweiter", "2").

Dann filtern wir die ungerade-Tupel, da wir nicht möchten, dass diese und enden Sie mit der rechten Tupel-Paaren ("First", 1"), ("Zweiter", "2") und so weiter.

Edit:

Ich eigentlich einverstanden mit der Stimmung der Kommentare - das ist, was ich denken würde, "clever" code - sieht smart aus, hat aber offensichtlich (und nicht so offensichtliche) Nachteile:

1. Leistung: der Durchlaufen werden muss
   werden zweimal Durchlaufen - für die gleiche
   Grund, es kann nicht verwendet werden
   Enumerables konsumieren Ihre
   Quelle, das heißt, Daten aus dem Netzwerk
   streams.

2. Wartung: Es ist nicht offensichtlich, was
   der code tut - wenn jemand anderes ist
   die Aufgabe, den code zu pflegen es
   könnte ärger geben, vor allem
   Punkt 1.

Gesagt, dass ich würde wahrscheinlich mit einem guten alten foreach Schleife mich angesichts der Wahl, oder mit einer Liste, die als Quelle der Sammlung eine for loop-so kann ich mit der index direkt.

InformationsquelleAutor BrokenGlass

Wenn Sie mit .NET 4.0, dann können Sie tuple-Objekt (siehe http://mutelight.org/articles/finally-tuples-in-c-sharp.html). Zusammen mit LINQ-sollte es Sie geben, was Sie brauchen. Wenn nicht, dann müssen Sie wahrscheinlich Ihre eigenen definieren Tupel zu tun, oder codieren Sie diese Zeichenfolgen, wie zum Beispiel "First:1", "Second:2" und dann entschlüsseln (auch mit LINQ).

InformationsquelleAutor freakish