Comment concaténer des listes en C #?

Si j'ai:

List<string> myList1;
List<string> myList2;

myList1 = getMeAList();
// Checked myList1, it contains 4 strings

myList2 = getMeAnotherList();
// Checked myList2, it contains 6 strings

myList1.Concat(myList2);
// Checked mylist1, it contains 4 strings... why?

J'ai exécuté un code similaire à celui-ci dans Visual Studio 2008 et défini des points d'arrêt après chaque exécution. Après myList1 = getMeAList();, myList1contient quatre chaînes, et j'ai appuyé sur le bouton plus pour m'assurer qu'elles n'étaient pas toutes nulles.

Après myList2 = getMeAnotherList();, myList2contient six chaînes, et j'ai vérifié qu'elles n'étaient pas nulles ... Après myList1.Concat(myList2);myList1 ne contenait que quatre chaînes. Pourquoi donc?

Concatrenvoie une nouvelle séquence sans modifier la liste d'origine . Essayez myList1.AddRange(myList2).

Essaye ça:

myList1 = myList1.Concat(myList2).ToList();

Concat renvoie un IEnumerable <T> qui est les deux listes réunies, il ne modifie aucune des listes existantes. En outre, comme il renvoie un IEnumerable, si vous souhaitez l'assigner à une variable qui est List <T>, vous devrez appeler ToList () sur le IEnumerable <T> qui est retourné.

targetList = list1.Concat(list2).ToList();

Ça marche bien, je pense. Comme indiqué précédemment, Concat renvoie une nouvelle séquence et lors de la conversion du résultat en List, il fait parfaitement le travail.

Il convient également de noter que Concat fonctionne en temps constant et en mémoire constante. Par exemple, le code suivant

        long boundary = 60000000;
        for (long i = 0; i < boundary; i++)
        {
            list1.Add(i);
            list2.Add(i);
        }
        var listConcat = list1.Concat(list2);
        var list = listConcat.ToList();
        list1.AddRange(list2);

donne les métriques de synchronisation / mémoire suivantes:

After lists filled mem used: 1048730 KB
concat two enumerables: 00:00:00.0023309 mem used: 1048730 KB
convert concat to list: 00:00:03.7430633 mem used: 2097307 KB
list1.AddRange(list2) : 00:00:00.8439870 mem used: 2621595 KB

Je sais que c'est vieux mais je suis tombé sur ce post en pensant que Concat serait ma réponse. Union a très bien fonctionné pour moi. Notez que cela ne renvoie que des valeurs uniques, mais sachant que j'obtenais de toute façon des valeurs uniques, cette solution a fonctionné pour moi.

namespace TestProject
{
    public partial class Form1 :Form
    {
        public Form1()
        {
            InitializeComponent();

            List<string> FirstList = new List<string>();
            FirstList.Add("1234");
            FirstList.Add("4567");

            // In my code, I know I would not have this here but I put it in as a demonstration that it will not be in the secondList twice
            FirstList.Add("Three");  

            List<string> secondList = GetList(FirstList);            
            foreach (string item in secondList)
                Console.WriteLine(item);
        }

        private List<String> GetList(List<string> SortBy)
        {
            List<string> list = new List<string>();
            list.Add("One");
            list.Add("Two");
            list.Add("Three");

            list = list.Union(SortBy).ToList();

            return list;
        }
    }
}

La sortie est:

One
Two
Three
1234
4567

Jetez un œil à ma mise en œuvre. Il est à l'abri des listes nulles.

 IList<string> all= new List<string>();

 if (letterForm.SecretaryPhone!=null)// first list may be null
     all=all.Concat(letterForm.SecretaryPhone).ToList();

 if (letterForm.EmployeePhone != null)// second list may be null
     all= all.Concat(letterForm.EmployeePhone).ToList(); 

 if (letterForm.DepartmentManagerName != null) // this is not list (its just string variable) so wrap it inside list then concat it 
     all = all.Concat(new []{letterForm.DepartmentManagerPhone}).ToList();