C#如何在使用List<T>的投影转换方法时提高性能？

结合 List<T> + LINQ 投影（Select）的底层原理，从执行机制、写法、数据结构、搭配用法、内存五个维度给出性能优化方案，附代码示例、对比和适用场景，适配 C#7.3。

一、先理清核心性能瓶颈

1. LINQ Select 默认延迟执行，多次枚举会重复计算投影逻辑；
2. 频繁调用 ToList()/ToArray() 会产生额外集合分配与拷贝；
3. 嵌套查询、匿名类、频繁装箱拆箱、闭包捕获变量会增加开销；
4. 链式写法搭配不当（如先投影再筛选）会放大计算量；
5. 大数据量下临时对象过多，引发 GC 压力。

---

二、具体优化方案（按优先级排序）

1. 调整链式顺序：先筛选(Where)，后投影(Select)

原理

Where 先过滤掉无用元素，再对剩余少量数据做投影，大幅减少投影执行次数。
错误顺序：先全量投影 → 再筛选（全量执行转换，浪费算力）
正确顺序：先筛选 → 再投影（只处理有效数据）

示例

// ❶ 低效：先投影再筛选，所有元素都执行转换
var bad = stuList
    .Select(s => new { s.Id, s.Name })
    .Where(x => x.Id > 1)
    .ToList();

// ❷ 高效：先筛选再投影，仅对符合条件元素转换
var good = stuList
    .Where(s => s.Id > 1)
    .Select(s => new { s.Id, s.Name })
    .ToList();

---

2. 避免重复枚举：一次投影，多次复用

原理

Select 是延迟执行，每遍历一次就重新执行一次投影逻辑。如果需要多次使用结果，务必只执行一次并落地为集合。

示例

// ❶ 低效：重复枚举，投影逻辑执行多次
var query = stuList.Select(s => s.Name);
foreach (var name in query) { } // 第1次执行
foreach (var name in query) { } // 第2次重复执行

// ❷ 高效：落地为 List，只投影一次，后续直接读取
List<string> nameList = stuList.Select(s => s.Name).ToList();
foreach (var name in nameList) { }
foreach (var name in nameList) { }

---

3. 大数据量：改用原生循环替代 LINQ Select

原理

LINQ 有委托调用、枚举器迭代的额外开销；for/foreach 原生循环无额外封装，纯数组寻址，性能最优（尤其百万级数据）。

对比示例

List<Student> source = GetLargeData(); // 模拟大数据集合

// ❶ LINQ Select（写法简洁，中小数据够用）
List<string> res1 = source.Select(s => s.Name).ToList();

// ❷ 原生 foreach 手动投影（高性能首选，大数据推荐）
List<string> res2 = new List<string>(source.Count); // 预先指定容量
foreach (var item in source)
{
    res2.Add(item.Name);
}

关键优化点：新建 List 时传入预估容量，避免运行中多次扩容拷贝。

---

4. 预分配集合容量，避免动态扩容开销

原理

List<T> 默认动态扩容（每次扩容会新建数组+全量拷贝）。投影前已知元素数量，手动指定 Capacity 可彻底规避扩容损耗。

示例

List<Student> list = ...;

// 低效：默认容量，可能多次扩容
List<int> idList = list.Select(s => s.Id).ToList();

// 高效：先初始化容量，再填充
List<int> idList = new List<int>(list.Count);
foreach (var s in list)
{
    idList.Add(s.Id);
}

---

5. 减少闭包捕获、避免局部变量频繁计算

原理

投影 Lambda 中捕获外部变量会生成闭包类，增加调用开销；复杂计算放在循环外，不要内嵌在投影逻辑里。

示例

decimal rate = 1.2m;

// ❶ 低效：Lambda 捕获外部变量 + 重复计算常量
var bad = list.Select(s => new { s.Name, Total = s.Score * rate }).ToList();

// ❷ 优化：简单场景影响小，复杂计算提取到外部
// 若有复杂逻辑，优先提取到循环外部
List<string> result = new List<string>(list.Count);
foreach (var s in list)
{
    decimal total = s.Score * rate; // 逻辑集中，无闭包
    result.Add($"{s.Name}:{total}");
}

---

6. 合理选择返回类型，按需落地

场景区分

1. 只需遍历一次：直接使用 IEnumerable<T>，不调用 ToList()，节省内存；
2. 需要多次读取/索引访问：必须 ToList() 落地；
3. 仅需数组：优先 ToArray()，部分场景比 List 读写更快。

// 只遍历一次，不用落地，节省内存
IEnumerable<string> onceUse = list.Select(s => s.Name);
foreach (var n in onceUse) { /* 业务逻辑 */ }

// 多次使用，落地为 List
List<string> multiUse = list.Select(s => s.Name).ToList();

---

7. 慎用匿名类、优先值类型/现有实体

原理

匿名类是引用类型，大量创建会产生 GC 压力；简单投影优先使用值类型（int/string/decimal）或已定义实体。

// ❶ 大量数据下不推荐：频繁创建匿名对象（引用类型）
var temp = list.Select(s => new { s.Id, s.Name }).ToList();

// ❷ 推荐：使用已定义 DTO 实体，可控且性能更稳
List<StudentDto> dtoList = new List<StudentDto>(list.Count);
foreach (var s in list)
{
    dtoList.Add(new StudentDto
    {
        StuId = s.Id,
        StuName = s.Name
    });
}

---

8. 禁止嵌套 Select / 多层 LINQ 链式

原理

多层嵌套投影会叠加枚举器、委托调用开销，数据量越大性能下滑越明显。

// 低效：嵌套投影，多层迭代
var bad = list
    .Select(s => s.Score)
    .Select(sc => sc + 10)
    .ToList();

// 高效：单次完成转换，合并逻辑
var good = new List<decimal>(list.Count);
foreach (var s in list)
{
    good.Add(s.Score + 10);
}

---

9. 超大数据：改用 Span（C#7.3 兼容补充）

如果是海量数据、纯值类型投影，使用 Span<T> 基于栈/托管内存直接操作，无集合分配，性能拉满。

C#7.3 已支持 Span<T>，适合高性能底层场景。

---

三、性能选型总结表

场景	推荐写法	理由
数据量 < 1万、追求简洁	LINQ 链式（先 Where 后 Select + ToList）	开发效率高，性能无瓶颈
数据量 1万 ~ 100万、追求性能	原生 foreach + 预分配 Capacity	消除 LINQ 枚举器开销，避免扩容
只需单次遍历	直接返回 IEnumerable<T>，不 ToList	减少内存分配
高频多次读取	强制 ToList() 落地	避免重复延迟执行
超大数据/底层高性能	Span<T> + 原生循环	零集合分配，内存效率最高

---

四、通用最佳实践（口诀）

1. 先筛后投：永远 Where 在 Select 前面；
2. 一次落地：多次复用就 ToList()，杜绝重复枚举；
3. 预分配容量：大数据投影必给 List 指定初始容量；
4. 复杂逻辑弃 LINQ：百万级以上优先原生循环；
5. 少用匿名类：海量对象用定义好的实体，降低 GC 压力。

---

五、完整综合优化示例（可直接运行）

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

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Score { get; set; }
}

public class StudentDto
{
    public int StuId { get; set; }
    public string StuName { get; set; }
}

class Program
{
    static void Main()
    {
        // 模拟数据源
        List<Student> source = new List<Student>
        {
            new Student{Id=1,Name="张三",Score=90},
            new Student{Id=2,Name="李四",Score=80},
            new Student{Id=3,Name="王五",Score=95}
        };

        // 综合优化写法：筛选 + 原生循环投影 + 预分配容量
        decimal filterScore = 85;
        List<StudentDto> result = new List<StudentDto>(source.Count);

        foreach (var item in source)
        {
            // 先筛选
            if (item.Score > filterScore)
            {
                // 再投影转换
                result.Add(new StudentDto
                {
                    StuId = item.Id,
                    StuName = item.Name
                });
            }
        }

        foreach (var dto in result)
        {
            Console.WriteLine($"{dto.StuId} - {dto.StuName}");
        }
    }
}