Fusionner plusieurs listes en une liste avec LINQ

Est-il un habile moyen de fusionner plusieurs Listes en une seule Liste à l'aide de LINQ to efficace de reproduire cela?

public class RGB
{
    public int Red { get; set; }
    public int Green { get; set; }
    public int Blue { get; set; }
    public RGB(int red, int green, int blue) { Red = red; Green = green; Blue = blue; }
}

public void myFunction()
{
    List<int> red = new List<int> { 0x00, 0x03, 0x06, 0x08, 0x09 };
    List<int> green = new List<int> { 0x00, 0x05, 0x06, 0x07, 0x0a };
    List<int> blue = new List<int> { 0x00, 0x02, 0x03, 0x05, 0x09 };

    List<RGB> colors = new List<RGB>();

    colors.Add(new RGB(red[0], green[0], blue[0]));
    colors.Add(new RGB(red[1], green[1], blue[1]));
    colors.Add(new RGB(red[2], green[2], blue[2]));
    colors.Add(new RGB(red[3], green[3], blue[3]));
    colors.Add(new RGB(red[4], green[4], blue[4]));
}

Ou, étant donné que les listes arrivent séparément, son plus efficace de les fusionner de manière séquentielle comme suit.

public class RGB
{
public int Red { get; set; }
public int Green { get; set; }
public int Blue { get; set; }
public RGB(int red, int green, int blue) { Red = red; Green = green; Blue = blue; }
}
public void myFunction()
{
List<int> red = new List<int> { 0x00, 0x03, 0x06, 0x08, 0x09 };
List<RGB> colors = new List<RGB>();
colors.Add(new RGB(red[0], 0, 0));
colors.Add(new RGB(red[1], 0, 0));
colors.Add(new RGB(red[2], 0, 0));
colors.Add(new RGB(red[3], 0, 0));
colors.Add(new RGB(red[4], 0, 0));
List<int> green = new List<int> { 0x00, 0x05, 0x06, 0x07, 0x0a };
colors[0].Green = green[0];
colors[1].Green = green[1];
colors[2].Green = green[2];
colors[3].Green = green[3];
colors[4].Green = green[4];
List<int> blue = new List<int> { 0x00, 0x02, 0x03, 0x05, 0x09 };
colors[0].Blue = blue[0];
colors[1].Blue = blue[1];
colors[2].Blue = blue[2];
colors[3].Blue = blue[3];
colors[4].Blue = blue[4];
}

source d'informationauteur tlum

  1. 23

    Vous êtes essentiellement en essayant de remonter la fermeture éclair de trois collections. Si seulement le LINQ Zip() pris en charge la compression de plus de deux simultanément. Mais hélas, il ne prend en charge que deux à la fois. Mais nous pouvons le faire fonctionner:

    var reds = new List<int> { 0x00, 0x03, 0x06, 0x08, 0x09 };
var greens = new List<int> { 0x00, 0x05, 0x06, 0x07, 0x0a };
var blues = new List<int> { 0x00, 0x02, 0x03, 0x05, 0x09 };
var colors =
reds.Zip(greens.Zip(blues, Tuple.Create),
(red, tuple) => new RGB(red, tuple.Item1, tuple.Item2)
)
.ToList();

    Bien sûr, il n'est pas très douloureux à écrire une extension de la méthode à trois (ou plus).

    public static IEnumerable<TResult> Zip<TFirst, TSecond, TThird, TResult>(
this IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
IEnumerable<TThird> third,
Func<TFirst, TSecond, TThird, TResult> resultSelector)
{
using (var enum1 = first.GetEnumerator())
using (var enum2 = second.GetEnumerator())
using (var enum3 = third.GetEnumerator())
{
while (enum1.MoveNext() && enum2.MoveNext() && enum3.MoveNext())
{
yield return resultSelector(
enum1.Current,
enum2.Current,
enum3.Current);
}
}
}

    Cela rend les choses beaucoup plus agréable:

    var colors =
reds.Zip(greens, blues,
(red, green, blue) => new RGB(red, green, blue)
)
.ToList();
  2. 10

    Oui - vous pouvez le faire comme ceci:

    List<int> red = new List<int> { 0x00, 0x03, 0x06, 0x08, 0x09 };
List<int> green = new List<int> { 0x00, 0x05, 0x06, 0x07, 0x0a };
List<int> blue = new List<int> { 0x00, 0x02, 0x03, 0x05, 0x09 };
List<RGB> colors = Enumerable
.Range(0, red.Count)
.Select(i => new RGB(red[i], green[i], blue[i]))
.ToList();
  3. 4
    var colours = red.Select((t, i) => new RGB(t, green[i], blue[i])).ToList();
  4. 1

    Vous pouvez utiliser l'ensemble des avec Zip zip un nombre arbitraire de IEnumerables en une seule fois.

    Voici comment vous pouvez le faire avec votre exemple:

    var colorLists = new List<int>[] { red, green, blue };
var rgbCount = red.Count;
var emptyTriples =
Enumerable.Repeat<Func<List<int>>>(() => new List<int>(), rgbCount)
.Select(makeList => makeList());
var rgbTriples = colorLists.Aggregate(
emptyTriples,
(partialTriples, channelValues) =>
partialTriples.Zip(
channelValues,
(partialTriple, channelValue) =>
{
partialTriple.Add(channelValue);
return partialTriple;
}));
var rgbObjects = rgbTriples.Select(
triple => new RGB(triple[0], triple[1], triple[2]));

    Généralement, en s'appuyant sur la fermeture à glissière sous-jacent à combiner évite les problèmes avec des variables d'entrée longueurs.

  5. 1

    Ici est une version simplifiée qui prend tout nombre de séquences (comme un tableau) de même type et de zips ensemble:

    public static IEnumerable<TResult> Zip<T, TResult>(this IEnumerable<T>[] sequences, Func<T[], TResult> resultSelector)
{
var enumerators = sequences.Select(s => s.GetEnumerator()).ToArray();
while(enumerators.All(e => e.MoveNext()))
yield return resultSelector(enumerators.Select(e => e.Current).ToArray());
}

    Pros

    • n'importe quel nombre de séquences
    • quatre lignes de code
    • une autre surcharge de LINQ .Zip() méthode
    • zips toutes les séquences à la fois au lieu d'enchaîner .Zip pour ajouter une séquence à chaque fois

    Contre

    • même type obligatoire pour toutes les séquences (pas un problème dans votre situation)
    • pas la vérification de même liste de longueur (ajouter une ligne, si vous en avez besoin)

    Utilisation

    Fusionner plusieurs listes en une liste avec LINQ

  6. 0

    Jeff Mercado fournit une réponse où trois séquences sont zippés. Ceci peut être généralisé à un nombre de séquences avec la limitation que toutes les séquences donc avoir le même type d'élément.

    Ici est généralisée zip opérateur qui s'occupe d'entrée variable longueurs et avec d'erreur de manipulation et d'élimination des agents recenseurs:

    static class EnumerableExtensions {
public static IEnumerable Zip<TSource, TResult>(
this IEnumerable<IEnumerable<TSource>> source,
Func<IEnumerable<TSource>, TResult> resultSelector
) {
if (source == null)
throw new ArgumentNullException("source");
if (resultSelector == null)
throw new ArgumentNullException("resultSelector");
var enumerators = new List<IEnumerator<TSource>>();
try {
foreach (var enumerable in source) {
if (enumerable == null)
throw new ArgumentNullException();
enumerators.Add(enumerable.GetEnumerator());
}
while (enumerators.Aggregate(true, (moveNext, enumerator) => moveNext && enumerator.MoveNext()))
yield return resultSelector(enumerators.Select(enumerator => enumerator.Current));
}
finally {
foreach (var enumerator in enumerators)
enumerator.Dispose();
}
}
}

    Les couleurs peuvent alors être calculée à l'aide de cette généralisé zip opérateur:

    var reds = new[] { 0x00, 0x03, 0x06, 0x08, 0x09 };
var greens = new[] { 0x00, 0x05, 0x06, 0x07, 0x0a };
var blues = new[] { 0x00, 0x02, 0x03, 0x05, 0x09 };
var colors = new[] { reds, greens, blues }
.Zip(rgb => new RGB(rgb.First(), rgb.Skip(1).First(), rgb.Skip(2).First()));

    Le code peut ne pas être aussi élégant que d'autres solutions, mais généralisée zip opérateur peut être utile dans certaines situations, et le code que j'ai fourni est efficace parce qu'elle seule itération de chaque séquence source une fois.