C++ 转 C#：核心思维转变与实战要点

黄金法则：

1. 纯托管对象（都是 C# 类）：交给 GC。
2. 非托管资源（文件、网络、数据库连接）：实现 IDisposable。
3. 大对象：考虑对象池。

类型系统：引用类型 vs 值类型

经常有人搞不清什么时候用 class，什么时候用 struct。这是一个关键区别，可以参考以下决策逻辑：

• 需要继承或多态吗？
  • 是 → 用 class
  • 否 → 继续判断
• 对象很小（<16 字节）吗？
  • 是 → 考虑 struct
  • 否 → 用 class
• 需要值语义（赋值时复制）吗？
  • 是 → 用 struct
  • 否 → 用 class

值语义示例：

// struct - 值语义
public struct Point {
    public int X, Y;
    
    // 推荐：让 struct 不可变
    public Point(int x, int y) => (X, Y) = (x, y);
}

Point p1 = new Point(10, 20);
Point p2 = p1; // 复制整个结构体
p2.X = 30;
Console.WriteLine(p1.X); // 输出 10，不受影响

// class - 引用语义
public class Person {
    public string Name;
}

Person person1 = new Person { Name = "Alice" };
Person person2 = person1; // 只复制引用
person2.Name = "Bob";
Console.WriteLine(person1.Name); // 输出 Bob！修改的是同一个对象

血的教训：

1. 不要在大 struct 里放引用类型（会有意外共享）。
2. 避免频繁装箱拆箱。
3. struct 适合小型的、逻辑上表示单个值的数据。

字符串处理：忘记 C++ 的习惯

在 C++ 里你可能习惯了用 strcmp，但在 C# 里字符串比较有几个坑需要注意。

string s1 = "hello";
string s2 = "HELLO";

// ❌ 问题 1：大小写敏感
if (s1 == s2) // false，但你可能想要 true

// ✅ 正确做法
if (string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase))

// ❌ 问题 2：文化敏感性
string s3 = "straße";
string s4 = "strasse";
if (s3 == s4) // false（德语文化中相同）

// ✅ 明确指定比较规则
if (string.Equals(s3, s4, StringComparison.InvariantCulture))

// ❌ 问题 3：字符串不可变
string text = "hello";
text.ToUpper(); // 返回新字符串，text 仍然是 "hello"

// ✅ 需要重新赋值
text = text.ToUpper();

还有一个重要建议：多用字符串插值，少用字符串连接。

// ❌ 性能差
string message = "Hello " + name + ", you are " + age + " years old";

// ✅ 性能好，可读性好
string message = $"Hello {name}, you are {age} years old";

// 大量拼接用 StringBuilder
var sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.Append(i).Append(", ");
}
string result = sb.ToString();

集合类的使用：忘记手动数组管理

总想用数组然后自己管理大小？这是 C++ 后遗症。在 C# 里，优先使用泛型集合。

// ❌ C++ 思维
int[] array = new int[10];
int count = 0;
// ... 手动管理插入、删除

// ✅ C# 方式
List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Remove(1);

// 字典的使用
Dictionary<string, int> dict = new Dictionary<string, int>();
dict["key"] = 10;

// 安全访问
if (dict.TryGetValue("key", out int value)) {
    // 使用 value
}

// 集合初始化器（语法糖）
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var person = new Person { Name = "John", Age = 30 };

集合使用法则：

1. 查询多、修改少 → 用 List<T>
2. 快速查找 → 用 Dictionary<TKey, TValue>
3. 需要排序 → 用 SortedDictionary 或 SortedList
4. 唯一性要求 → 用 HashSet<T>
5. 先进先出 → 用 Queue<T>
6. 后进先出 → 用 Stack<T>

现代 C# 特性：拥抱变化

=>、var、$" 这些符号必须学，它们是提高生产力的利器。

阶段 1：立即掌握

// 1. var 类型推断
var list = new List<string>(); // 编译器知道类型
var count = 10; // 知道是 int

// 2. 属性初始化器
public class Person {
    public string Name { get; set; } = "Unknown";
    public int Age { get; set; }
}

// 3. 字符串插值
Console.WriteLine($"Result: {Calculate()}");

// 4. 空条件运算符
string name = person?.Name ?? "Default";

阶段 2：尽快学习

// 1. 模式匹配（C# 7+）
if (obj is int i && i > 0) {
    // 直接使用 i
}

// 2. switch 表达式
string result = values switch {
    1 => "One",
    2 => "Two",
    _ => "Many"
};

// 3. 记录类型（C# 9+）
public record Person(string FirstName, string LastName);

// 4. with 表达式
var newPerson = person with { LastName = "Smith" };

阶段 3：深度掌握

// 1. 可空引用类型（C# 8+）
#nullable enable
string? nullableString = null; // 明确可空
string nonNullString = "hello"; // 明确非空

// 2. 顶级语句（C# 9+）
// 不需要写 namespace、class、Main 方法
Console.WriteLine("Hello World!");

// 3. 文件范围的命名空间（C# 10+）
namespace MyApp;
// 整个文件都在这个命名空间里

异步编程：从回调地狱到天堂

async/await 是 C# 最棒的特性之一，它让你从原始社会升级到了现代社会。

// 😰 旧方式（回调地狱）
client.GetData(url, result => {
    ProcessData(result, processed => {
        SaveData(processed, saved => {
            UpdateUI(saved);
        });
    });
});

// 😊 async/await 方式
public async Task ProcessAsync() {
    var data = await client.GetDataAsync(url);
    var processed = await ProcessDataAsync(data);
    var saved = await SaveDataAsync(processed);
    UpdateUI(saved);
}

async/await 黄金法则：

1. async 传染性：一旦用了 async，调用链上通常都需要 async。
2. 命名规范：异步方法以 Async 结尾。
3. 避免 async void：除了事件处理器，都用 async Task。
4. 配置等待：ConfigureAwait(false) 避免死锁。
5. 不要阻塞：绝对不要用 .Result 或 .Wait()。

// ❌ 错误做法
public string GetData() {
    return GetDataAsync().Result; // 可能导致死锁！
}

// ✅ 正确做法
public async Task<string> GetDataAsync() {
    return await httpClient.GetStringAsync(url);
}

// ✅ 在控制台程序可以这样
public static async Task Main(string[] args) {
    var data = await GetDataAsync();
    Console.WriteLine(data);
}

调试和排错：新的思维方式

C# 的调试体验更好，但要注意一些新问题。

1. 异常而不是错误码

// ❌ C++ 思维
int result = DoOperation();
if (result != SUCCESS) {
    // 处理错误
}

// ✅ C# 方式
try {
    await DoOperationAsync();
} catch (OperationCanceledException ex) {
    // 任务被取消
} catch (HttpRequestException ex) {
    // 网络错误
} catch (Exception ex) {
    // 最后兜底
    _logger.LogError(ex, "操作失败");
    throw; // 重新抛出，保留堆栈
}

2. 使用日志而不是 printf

// 结构化日志
_logger.LogInformation("用户 {UserId} 执行了操作 {Action}", userId, actionName);

// 带有异常信息的日志
try {
    // ...
} catch (Exception ex) {
    _logger.LogError(ex, "处理用户 {UserId} 时出错", userId);
}

3. 利用 Visual Studio 的强大功能

• 条件断点：右键断点设置条件
• 数据断点：监视对象变化
• 即时窗口：执行任意代码
• 诊断工具：内存分析、性能分析

项目管理：忘记 makefile

忘记 makefile 和手动拷贝 dll 吧！C# 有 NuGet。

1. 依赖管理：在 .csproj 文件里定义
2. 包恢复：自动下载依赖
3. 版本控制：语义化版本管理

<!-- 项目文件示例 -->
<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <Nullable>enable</Nullable>
    </PropertyGroup>
    <ItemGroup>
        <!-- 添加 NuGet 包 -->
        <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
        <PackageReference Include="AutoMapper" Version="10.1.1" />
    </ItemGroup>
</Project>

日常检查清单：

• 代码中是否还有 public 字段？（应该用属性）
• 是否实现了 IDisposable？（如果有非托管资源）
• 异步方法是否以 Async 结尾？
• 是否处理了可能的 null？
• 是否使用了合适的集合类型？
• 字符串比较是否指定了比较规则？
• 是否避免了装箱拆箱？
• 是否用了 using 管理资源？

最后的忠告

转型最大的障碍不是技术，而是思维习惯。你需要：

1. 从控制狂到信任者：相信 GC，相信框架
2. 从手动挡到自动挡：让工具为你工作
3. 从微观到宏观：关注业务逻辑而不是内存布局
4. 从复杂到简洁：利用现代语言特性

别急，建议分阶段学习：

• 第 1 周：掌握基础（值类型 vs 引用类型、属性 vs 字段、基本集合使用）
• 第 2 周：深入核心（async/await、LINQ 基础、异常处理）
• 第 3 周：现代特性（模式匹配、记录类型、可空引用类型）
• 第 4 周：生态系统（Entity Framework、ASP.NET Core 基础、依赖注入）

记住，不要试图一次性掌握所有东西。写代码时遇到问题再查，实践中学习最快。有问题随时查阅文档或社区。祝你转型顺利！

'写 C# 代码，不要用 C++ 思维'。