嘿，这个问题问得很到位！循环确实能解决，但咱们在C#里有不少更高效、更简洁的方案，毕竟框架自带的方法大多都做了底层优化，比手动写循环靠谱多了。下面给你拆解几种实用的实现方式：

1. 使用List<T>.AddRange方法（修改原列表的最优选择） #

AddRange是List专门为批量添加元素设计的方法，内部已经做了容量预计算和数组扩容优化，比手动循环逐个Add要高效得多，代码也更简洁。

修改原列表的代码示例： #

var originalList = new List<int> { 1, 2, 3, 4 };
originalList.AddRange(originalList);
// 此时originalList就变成了 [1,2,3,4,1,2,3,4]

如果要生成新列表（不修改原列表）： #

可以预先指定新列表的容量（原列表长度的2倍），避免List自动扩容带来的性能损耗：

var originalList = new List<int> { 1, 2, 3, 4 };
var doubledList = new List<int>(originalList.Count * 2);
doubledList.AddRange(originalList);
doubledList.AddRange(originalList);

2. 使用LINQ的Concat方法（适合生成新列表的场景） #

如果你习惯用LINQ风格的代码，Concat可以快速拼接两个序列，返回一个新的IEnumerable<T>，再转成List即可。不过要注意，转List时预先指定容量能进一步提升效率。

代码示例： #

var originalList = new List<int> { 1, 2, 3, 4 };
// 基础写法
var doubledList = originalList.Concat(originalList).ToList();

// 更高效的写法（预先指定容量）
var doubledList = new List<int>(originalList.Count * 2);
doubledList.AddRange(originalList.Concat(originalList));

3. 手动数组拷贝（极致性能场景） #

如果你的场景对性能要求极高，可以直接操作List的内部数组（利用内存拷贝），这是效率最高的方式，但缺点是依赖List的内部实现，不同.NET版本可能有变化，谨慎使用。

代码示例（不依赖反射的安全写法）： #

var originalList = new List<int> { 1, 2, 3, 4 };
int originalCount = originalList.Count;
// 预先设置容量，避免自动扩容
originalList.Capacity = originalCount * 2;
// 利用Array.Copy做内存级拷贝
Array.Copy(originalList.ToArray(), 0, originalList.GetRange(originalCount, originalCount).ToArray(), 0, originalCount);

更极致的反射写法（不推荐日常使用）： #

var originalList = new List<int> { 1, 2, 3, 4 };
int originalCount = originalList.Count;
// 获取List内部的数组字段
var itemsField = typeof(List<int>).GetField("_items", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
int[] items = (int[])itemsField.GetValue(originalList);
// 内存拷贝
Array.Copy(items, 0, items, originalCount, originalCount);
// 更新List的Count属性
originalList.Count = originalCount * 2;

总结一下： #

• 日常开发中，AddRange 是首选，既简洁又高效；
• 生成新列表时，优先用预先指定容量+两次AddRange的组合；
• 手动数组拷贝只适合极端性能需求的场景，不推荐常规使用。

内容的提问来源于stack exchange，提问作者Liu_064