How to Join Two Lists Together in C#

1. C# Program to Join Two Lists Together Using the AddRange() Method
2. C# Program to Join Two Lists Together Using the Concat() Method (LINQ)
3. C# Program to Join Two Lists Together Using the ForEach Loop
4. C# Program to Join Two Lists Together Using the Union() Method (LINQ)
5. C# Program to Join Two Lists Together Using the InsertRange() Method
6. C# Program to Join Two Lists Together Using the Zip() Method
7. Conclusion

Combining or joining two lists is a common operation in C# programming, and there are several approaches to achieve this.

In this article, we’ll explore various methods, each catering to different scenarios and preferences. The examples provided will cover a range of use cases, from simple concatenation to more nuanced operations.

C# Program to Join Two Lists Together Using the AddRange() Method

One straightforward method to combine or concatenate two lists is by using the AddRange() method. This method is a member of the List<T> class in C#.

It is designed to add the elements of a specified collection to the end of the List<T>. The syntax for using AddRange() to join two lists is as follows:

List1.AddRange(List2);

Here, List1 is the target list to which we want to add elements, and List2 is the source list whose elements we want to append to List1.

Internally, the AddRange() method iterates over the elements of the source list (List2), adding each element to the end of the target list (List1). This process efficiently appends the entire content of List2 to List1 in a single operation.

Now, let’s delve into a complete working example to illustrate how the AddRange() method can be used to join two lists:

using System;
using System.Collections.Generic;

class Program {
  static void Main() {
    List<string> fruits = new List<string>() { "Apple", "Banana", "Orange", "Mango" };
    List<string> vegetables = new List<string>() { "Potato", "Tomato", "Cauliflower", "Onion" };

    fruits.AddRange(vegetables);

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", fruits));
  }
}

Output:

Combined List: Apple, Banana, Orange, Mango, Potato, Tomato, Cauliflower, Onion

In this example, we start by declaring two lists: fruits and vegetables. These lists contain strings representing different fruits and vegetables, respectively.

The necessary step in joining these lists is achieved through the line:

fruits.AddRange(vegetables);

Here, the AddRange() method is called on the fruits list, and vegetables is passed as the parameter. This single line of code effectively appends all elements from the vegetables list to the end of the fruits list.

C# Program to Join Two Lists Together Using the Concat() Method (LINQ)

Another method we can use for combining or concatenating two lists is the Concat() method. This method is part of the LINQ (Language-Integrated Query) extension methods.

The Concat() method is employed to concatenate two sequences into a single sequence. In the context of lists, it can be used as follows:

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

Here, list1 and list2 are the two lists that we intend to join. The result is assigned to combinedList, and ToList() is used to materialize the concatenated sequence into a new list.

The Concat() method creates a new sequence that includes all elements from the first list (list1) followed by all elements from the second list (list2). The result is a seamless combination of the two lists without any duplicates.

Now, let’s explore a complete working example to illustrate how the Concat() method can be utilized to join two lists:

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

class Program {
  static void Main() {
    List<string> colors = new List<string>() { "Red", "Green", "Blue" };
    List<string> shapes = new List<string>() { "Circle", "Square", "Triangle" };

    var combinedList = colors.Concat(shapes).ToList();

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", combinedList));
  }
}

Output:

Combined List: Red, Green, Blue, Circle, Square, Triangle

In this example, we initialize two lists: colors and shapes, containing strings representing different colors and shapes, respectively.

Specifically, the merging process is achieved through the line:

var combinedList = colors.Concat(shapes).ToList();

Here, the Concat() method is invoked on the colors list, and shapes is passed as the parameter. The result is stored in combinedList.

This single line concisely merges the elements of both lists, creating a new list that seamlessly incorporates the contents of colors followed by those of shapes.

C# Program to Join Two Lists Together Using the ForEach Loop

When it comes to combining or concatenating two lists in C#, using a traditional approach like the ForEach loop can also be both intuitive and effective.

The ForEach loop is a control flow statement in C# that iterates over the elements of a collection. In the context of joining two lists, the syntax is as follows:

ListToAdd.ForEach(item => TargetList.Add(item));

Here, ListToAdd represents the source list whose elements we want to add, and TargetList is the list to which we are appending elements.

The ForEach loop iterates over each element in the source list (ListToAdd), and for each iteration, the specified lambda expression is executed. In this case, the lambda expression adds the current element to the target list (TargetList).

This process continues until all elements from the source list are added to the target list.

Now, let’s dive into a complete working example to illustrate how the ForEach loop can be employed to join two lists:

using System;
using System.Collections.Generic;

class Program {
  static void Main() {
    List<string> animals = new List<string>() { "Lion", "Elephant", "Giraffe" };
    List<string> birds = new List<string>() { "Eagle", "Parrot", "Owl" };

    birds.ForEach(bird => animals.Add(bird));

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", animals));
  }
}

Output:

Combined List: Lion, Elephant, Giraffe, Eagle, Parrot, Owl

In this example, we initialize two lists: animals and birds, containing strings representing different animal types and bird species, respectively.

Combining the animals and birds lists is performed through the line:

birds.ForEach(bird => animals.Add(bird));

Here, the ForEach loop is applied to the birds list. For each iteration, the specified lambda expression is executed, adding the current bird to the animals list.

This concisely concatenates the contents of the birds list to the animals list.

C# Program to Join Two Lists Together Using the Union() Method (LINQ)

Another method we can use to concatenate or join two lists is the Union() method, a LINQ extension method designed for finding unique elements in two sequences.

When applied to lists, the syntax looks like this:

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

Here, list1 and list2 are the two lists you aim to join. The result is stored in combinedList, and ToList() is used to materialize the concatenated sequence into a new list.

How the Union() method works is it creates a new sequence containing all distinct elements from both lists (list1 and list2). This ensures that each element is included only once in the resulting list, eliminating duplicates.

Now, let’s explore a complete working example to illustrate how the Union() method can be leveraged to join two lists:

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

class Program {
  static void Main() {
    List<int> numbers1 = new List<int>() { 1, 2, 3, 4, 5 };
    List<int> numbers2 = new List<int>() { 3, 4, 5, 6, 7 };

    var combinedList = numbers1.Union(numbers2).ToList();

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", combinedList));
  }
}

Output:

Combined List: 1, 2, 3, 4, 5, 6, 7

In this example, we initialize two lists: numbers1 and numbers2, each containing integers. The goal is to combine these lists while ensuring that each number appears only once in the result.

To do this, we have the line:

var combinedList = numbers1.Union(numbers2).ToList();

Here, the Union() method is invoked on the numbers1 list, and numbers2 is passed as the parameter. The result is stored in combinedList.

This single line easily merges the distinct elements of both lists, creating a new list that includes all unique numbers from numbers1 and numbers2.

C# Program to Join Two Lists Together Using the InsertRange() Method

The InsertRange() method is also an efficient way to concatenate or join two lists. Unlike the other methods, InsertRange() allows you to insert the elements of one list into another at a specific index.

The InsertRange() method is part of the List<T> class in C#. The syntax for using InsertRange() to join two lists is as follows:

List1.InsertRange(index, List2);

Here, List1 is the target list where we want to add elements, and List2 is the source list whose elements we want to insert. The index parameter denotes the position in the target list where the elements from the source list will be inserted.

The InsertRange() method iterates over the elements of the source list (List2) and inserts each element into the target list (List1) at the specified index. This provides flexibility in controlling where the elements from the source list become part of the target list.

Now, let’s see an example to illustrate how the InsertRange() method can be utilized to join two lists:

using System;
using System.Collections.Generic;

class Program {
  static void Main() {
    List<string> cars = new List<string>() { "Toyota", "Ford", "Honda" };
    List<string> bikes = new List<string>() { "Harley", "Ducati", "Honda" };

    cars.InsertRange(1, bikes);

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", cars));
  }
}

Output:

Combined List: Toyota, Harley, Ducati, Honda, Ford, Honda

In this code example, we have two lists: cars and bikes, each containing strings representing different vehicle brands. The goal is to combine these lists, inserting the elements from bikes into the cars list at a specific index.

We achieve this particular goal through the line:

cars.InsertRange(1, bikes);

Here, the InsertRange() method is called on the cars list. The elements from the bikes list will be inserted at index 1 in the cars list.

This line seamlessly merges the elements of both lists while maintaining control over the insertion point.

C# Program to Join Two Lists Together Using the Zip() Method

The Zip() method is also a versatile approach for combining two lists by creating a new list of pairs. Each pair contains elements from the corresponding positions in the input lists.

This method is particularly useful when you want to merge lists element-wise. The syntax for using Zip() to join two lists is as follows:

var combinedList = list1.Zip(list2, (element1, element2) => element1 + " " + element2).ToList();

Here, list1 and list2 are the two lists you intend to join. The lambda expression (element1, element2) => element1 + " " + element2 defines how to combine elements from the two lists.

In this syntax, the elements are concatenated with a space in between. The result is a new list that pairs elements from list1 and list2 based on their positions.

Let’s illustrate this method with a working example:

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

class Program {
  static void Main() {
    List<string> countries = new List<string>() { "USA", "Canada", "France" };
    List<string> capitals = new List<string>() { "Washington", "Ottawa", "Paris" };

    var combinedList =
        countries.Zip(capitals, (country, capital) => $"{country} - {capital}").ToList();

    Console.Write("Combined List: ");
    Console.WriteLine(string.Join(", ", combinedList));
  }
}

Output:

Combined List: USA - Washington, Canada - Ottawa, France - Paris

In this example, we have two lists: countries and capitals, each containing strings representing different countries and their corresponding capitals. The Zip() method is then applied to pair elements from these lists, combining them with a hyphen.

The line responsible for this operation is:

var combinedList = countries.Zip(capitals, (country, capital) => $"{country} - {capital}").ToList();

Here, the Zip() method creates pairs of elements from countries and capitals, and the lambda expression defines how to combine them. The resulting list, combinedList, contains the combined strings for each pair of elements.

Conclusion

In summary, joining two lists in C# offers multiple approaches, each with its advantages. Depending on your specific requirements and coding style, you can choose the method that best fits your needs.

Whether you prefer the simplicity of AddRange(), the expressive power of LINQ methods, the traditional ForEach loop, or the flexibility of InsertRange() and Zip(), C# provides a versatile set of tools for list concatenation.