Comment prendre chacun des deux éléments de IEnumerable comme une paire?

Un paresseux extension de la méthode pour y parvenir est:

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

Noter que si le nombre d'éléments qui se passe pour ne pas être encore cette va lancer. Un autre moyen serait d'utiliser cette extension de la méthode split de la source, de collecte en morceaux de 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;
}

Alors vous pouvez faire:

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

Enfin, utiliser uniquement les méthodes d'extension:

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

OriginalL'auteur eulerfx

Vous pouvez faire ce travail à l'aide de LINQ .Zip() méthode d'extension:

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

Fondamentalement, l'approche est refermé la source Énumérable avec lui-même, en sautant le premier élément, pour la deuxième énumération est un qui va vous donner les paires ("Première, "1"), ("1", "Deuxième"), ("Deuxième", "2").

Puis nous sommes filtrage de l'étrange tuples car nous ne voulons pas que ceux-ci et jusqu'à la fin avec le droit tuple paires ("Premier", 1"), ("Deuxième", "2") et ainsi de suite.

Edit:

J'ai fait d'accord avec le sentiment de la commentaires - c'est ce que je considère être "intelligent" code ressemble à puce, mais il est évident (et pas si évident) inconvénients:

1. Performance: l'Énumération a pour
   parcourir deux fois pour la même
   raison, il ne peut pas être utilisé sur
   Enumerables qui consomment leur
   la source, c'est à dire des données à partir du réseau
   les ruisseaux.

2. Entretien: Il n'est pas évident ce
   le code n' - si quelqu'un d'autre
   chargé de tenir à jour le code
   peut-être des ennuis à venir, surtout
   point 1.

Cela dit, je serais probablement utiliser un bon vieux foreach boucle de moi-même donné le choix, ou avec une liste comme source de collecte d'un for boucle si je peux utiliser l'index directement.

OriginalL'auteur BrokenGlass

Si vous êtes en utilisant .NET 4.0, vous pouvez utiliser un tuple de l'objet (voir http://mutelight.org/articles/finally-tuples-in-c-sharp.html). Avec LINQ il devrait vous donner ce dont vous avez besoin. Si non, alors vous avez probablement besoin de définir votre propre tuples de le faire ou encoder ces chaînes, comme par exemple "First:1", "Second:2" et puis le décoder (également avec LINQ).

OriginalL'auteur freakish