一种方法:List.AddRange()取决于类型?

就像这样:

firstList.AddRange (secondList);

或者，你可以使用System.Linq中定义的“Union”扩展方法。 使用'Union'，你还可以指定一个比较器，它可以用来指定一个项是否应该合并。

是这样的:

List<int> one = new List<int> { 1, 2, 3, 4, 5 };
List<int> second=new List<int> { 1, 2, 5, 6 };

var result = one.Union (second, new EqComparer ());

foreach( int x in result )
{
    Console.WriteLine (x);
}
Console.ReadLine ();

#region IEqualityComparer<int> Members
public class EqComparer : IEqualityComparer<int>
{
    public bool Equals( int x, int y )
    {
        return x == y;
    }

    public int GetHashCode( int obj )
    {
        return obj.GetHashCode ();
    }
}
#endregion

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

我想它运行得很好。如前所述，Concat返回一个新的序列，在将结果转换为List时，它完美地完成了工作。使用AddRange方法时，隐式转换有时可能会失败。

你可以试试:

List<string> a = new List<string>();
List<string> b = new List<string>();

a.AddRange(b);

AddRange的MSDN页面

这保留了列表的顺序，但没有删除任何重复项(Union会这样做)。

这确实会改变列表a。如果你想保留原始列表，那么你应该使用Concat(正如在其他答案中指出的那样):

var newList = a.Concat(b);

只要a不为空，就返回一个IEnumerable。

AddRange方法

aList.AddRange( anotherList );

我只是想测试Union如何使用默认比较器处理引用类型对象的重叠集合。

我的目标是:

class MyInt
{
    public int val;

    public override string ToString()
    {
        return val.ToString();
    }
}

我的测试代码是:

MyInt[] myInts1 = new MyInt[10];
MyInt[] myInts2 = new MyInt[10];
int overlapFrom = 4;
Console.WriteLine("overlapFrom: {0}", overlapFrom);

Action<IEnumerable<MyInt>, string> printMyInts = (myInts, myIntsName) => Console.WriteLine("{2} ({0}): {1}", myInts.Count(), string.Join(" ", myInts), myIntsName);

for (int i = 0; i < myInts1.Length; i++)
    myInts1[i] = new MyInt { val = i };
printMyInts(myInts1, nameof(myInts1));

int j = 0;
for (; j + overlapFrom < myInts1.Length; j++)
    myInts2[j] = myInts1[j + overlapFrom];
for (; j < myInts2.Length; j++)
    myInts2[j] = new MyInt { val = j + overlapFrom };
printMyInts(myInts2, nameof(myInts2));

IEnumerable<MyInt> myUnion = myInts1.Union(myInts2);
printMyInts(myUnion, nameof(myUnion));

for (int i = 0; i < myInts2.Length; i++)
    myInts2[i].val += 10;
printMyInts(myInts2, nameof(myInts2));
printMyInts(myUnion, nameof(myUnion));

for (int i = 0; i < myInts1.Length; i++)
    myInts1[i].val = i;
printMyInts(myInts1, nameof(myInts1));
printMyInts(myUnion, nameof(myUnion));

输出结果为:

overlapFrom: 4
myInts1 (10): 0 1 2 3 4 5 6 7 8 9
myInts2 (10): 4 5 6 7 8 9 10 11 12 13
myUnion (14): 0 1 2 3 4 5 6 7 8 9 10 11 12 13
myInts2 (10): 14 15 16 17 18 19 20 21 22 23
myUnion (14): 0 1 2 3 14 15 16 17 18 19 20 21 22 23
myInts1 (10): 0 1 2 3 4 5 6 7 8 9
myUnion (14): 0 1 2 3 4 5 6 7 8 9 20 21 22 23

所以，一切正常。