Good way to combine two List<T>s in .NET 2.0?

Question

I have two lists I need to form the union of, but I'm in .NET 2.0 so the Union() method appears to be out. These are lists of integers, so no problem with the equality comparisons. What's a good way to go about this?

Answer 1

You could just add them together and remove the duplicates:

  public List<T> Union<T>(List<T> firstList, List<T> secondList)
  {
     Dictionary<T, int> tmp = new Dictionary<T, int>();

     foreach (T val in firstList)
     {
        tmp[val] = 1;
     }

     foreach (T val in secondList)
     {
        tmp[val] = 1;
     }

     return new List<T>(tmp.Keys);
  }

Answer 2

How about a simple foreach, only adding elements that aren't already in the list:

foreach (int item in list2)
{
    if (!list1.Contains(item))
    {
        list1.Add(item);
    }
}

This will preserve the order of the lists.

Answer 3

You could use linqbridge to let you use LINQ to Objects while still targeting Framework 2.0, if you have Visual Studio 2008.

And push, push, push to move to .NET 3.5. LINQ and lambdas change the way you think about code (for the better, IMHO).

Answer 4

What about (using Dictionary keys as a hashtable):

public static List<T> Union<T>(List<T> first, List<T> second) {
    List<T> newList = new List<T>(first.Count + second.Count);
    Dictionary<T, object> firstItems = new Dictionary<T, object>(first.Count);

    foreach (T item in first) {
        newList.Add(item);
        firstItems.Add(item, null); 
    }

    foreach (T item in second) {
        if (!firstItems.ContainsKey(item) {
            newList.Add(item);
        }
    }

    return newList;
}

This will maintain the item order in first and second, while still using an O(1) check for duplicate items between the lists