Méthodes efficaces pour combiner des listes en C#

La combinaison de listes est une opération fondamentale en programmation C#. Cet article explore plusieurs techniques efficaces pour joindre des listes, chacune ayant ses propres avantages et cas d’utilisation. Nous examinerons différentes approches, allant de la simple concaténation à des opérations plus sophistiquées comme la fusion avec suppression des doublons ou le couplage d’éléments.

Table des matières

1. Joindre des listes avec AddRange()
2. Concaténer des listes avec Concat() (LINQ)
3. Jointure manuelle de listes avec une boucle foreach
4. Combiner des listes et supprimer les doublons avec Union() (LINQ)
5. Insérer une liste dans une autre avec InsertRange()
6. Coupler des éléments avec la méthode Zip()
7. Conclusion

Joindre des listes avec AddRange()

La méthode AddRange() offre un moyen direct et efficace d’ajouter une liste à la fin d’une autre. Cette méthode modifie la liste originale.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        list1.AddRange(list2);

        Console.WriteLine("Liste jointe :");
        Console.WriteLine(string.Join(" ", list1)); // Sortie : 1 2 3 4 5 6
    }
}

Concaténer des listes avec Concat() (LINQ)

La méthode Concat() de LINQ fournit une approche en lecture seule pour la concaténation de listes. Elle crée une nouvelle liste contenant tous les éléments des deux listes d’entrée sans modifier les originales.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        var joinedList = list1.Concat(list2).ToList();

        Console.WriteLine("Liste jointe :");
        Console.WriteLine(string.Join(" ", joinedList)); // Sortie : 1 2 3 4 5 6
    }
}

Jointure manuelle de listes avec une boucle foreach

Une approche manuelle utilisant une boucle foreach offre un contrôle maximal, particulièrement utile lorsqu’il s’agit d’une logique de jointure plus complexe.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };
        List<int> joinedList = new List<int>();

        joinedList.AddRange(list1);
        foreach (int num in list2)
        {
            joinedList.Add(num);
        }

        Console.WriteLine("Liste jointe :");
        Console.WriteLine(string.Join(" ", joinedList)); // Sortie : 1 2 3 4 5 6

    }
}

Combiner des listes et supprimer les doublons avec Union() (LINQ)

La méthode Union() fusionne efficacement deux listes tout en éliminant les entrées en double.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 3, 4, 5 };

        var joinedList = list1.Union(list2).ToList();

        Console.WriteLine("Liste jointe (doublons supprimés) :");
        Console.WriteLine(string.Join(" ", joinedList)); // Sortie : 1 2 3 4 5
    }
}

Insérer une liste dans une autre avec InsertRange()

InsertRange() permet l’insertion précise d’une liste dans une autre à un index spécifié.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        list1.InsertRange(2, list2); // Insère list2 à partir de l'index 2

        Console.WriteLine("Liste jointe :");
        Console.WriteLine(string.Join(" ", list1)); // Sortie : 1 2 4 5 6 3
    }
}

Coupler des éléments avec la méthode Zip()

La méthode Zip() couple les éléments correspondants de deux listes en fonction de leur index. Ceci est avantageux lorsque vous devez combiner des éléments qui ont une correspondance relationnelle.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<string> list1 = new List<string> { "A", "B", "C" };
        List<int> list2 = new List<int> { 1, 2, 3 };

        var zippedList = list1.Zip(list2, (str, num) => str + num).ToList();

        Console.WriteLine("Liste zippée :");
        Console.WriteLine(string.Join(" ", zippedList)); // Sortie : A1 B2 C3
    }
}

Conclusion

C# offre un riche ensemble d’outils pour la manipulation de listes. Le choix de la méthode dépend fortement des exigences spécifiques de votre tâche. Tenez compte du besoin de modifier les listes originales, de supprimer les doublons ou de coupler les éléments correspondants lors de la sélection de l’approche la plus appropriée.