1. 利用 Null 条件运算符 (?. 和 ?[]) 简化 Null 检查

避免冗长的 if (obj != null) 检查，特别是在访问链式属性或索引器时。

// 旧方法
string postalCode = "UNKNOWN";
if (user != null && user.Address != null && user.Address.PostalCode != null) {
    postalCode = user.Address.PostalCode;
}

// 使用 ?.
string postalCode = user?.Address?.PostalCode ?? "UNKNOWN"; // 配合 ?? 更佳

// 访问索引器
int? firstCustomerId = customers?[0]?.Id;

• 好处: 代码更简洁、可读性更高。

2. 使用 Null 合并运算符 (?? 和 ??=) 提供默认值

?? 用于在左侧操作数为 null 时提供默认值。??= (Null 合并赋值运算符) 则在变量为 null 时才进行赋值。

// ??
string name = possiblyNullName ?? "Default Name";

// ??= (C# 8.0+)
List<int> numbers = null;
(numbers ??= new List<int>()).Add(5); // 如果 numbers 是 null，则 new 一个 List 并赋值给 numbers，然后 Add
Console.WriteLine(numbers.Count); // 输出 1

• 好处: 简化默认值设置和延迟初始化逻辑。

3. 字符串内插 (#34;") 替代 string.Format

让字符串格式化更直观、易读。

string name = "World";
int year = DateTime.Now.Year;

// 旧方法
string greeting = string.Format("Hello, {0}! Welcome to {1}.", name, year);

// 使用 #34;"
string greeting = #34;Hello, {name}! Welcome to {year}.";

// 支持格式化和对齐
decimal price = 19.99m;
Console.WriteLine(#34;The price is {price:C2}."); // 输出货币格式
Console.WriteLine(#34;Item: {'Apple',-10} | Price: {price,8:C}"); // 对齐

• 好处: 提高可读性，减少参数位置错误。

4. 表达式主体成员 (=>) 简化简单方法和属性

对于只有单个表达式的方法、属性、构造函数、终结器和索引器，可以使用 => 语法。

// 传统方法
public int Add(int a, int b)
{
    return a + b;
}
// 使用 =>
public int Add(int a, int b) => a + b;

// 传统只读属性
private string _name;
public string Name
{
    get { return _name; }
}
// 使用 =>
public string Name => _name; // get 访问器

// 也可以用于 set (虽然较少见) 或方法
public void PrintName() => Console.WriteLine(Name);

• 好处: 代码更紧凑。

5. 模式匹配 (is 和 switch 表达式)

C# 7.0 及以后版本引入了强大的模式匹配功能，简化类型检查和数据提取。

object shape = GetShape();

// is 模式匹配
if (shape is Circle c) {
    Console.WriteLine(#34;Circle with radius {c.Radius}");
} else if (shape is Rectangle r && r.Width > 0) { // 还可以加条件
    Console.WriteLine(#34;Rectangle with area {r.Width * r.Height}");
}

// switch 表达式 (C# 8.0+) - 更简洁
var description = shape switch
{
    Circle c => #34;Circle radius {c.Radius}",
    Rectangle r when r.Width > 10 => #34;Large rectangle area {r.Width * r.Height}", // when 子句
    Rectangle r => #34;Rectangle area {r.Width * r.Height}",
    Square s => #34;Square side {s.Side}",
    _ => "Unknown shape" // default 分支
};
Console.WriteLine(description);

• 好处: 替代冗长的 if-else if 或旧式 switch，代码更具表现力。

6. 使用 using 声明 (C# 8.0+) 简化资源管理

不再需要显式的大括号，using 变量的作用域持续到当前代码块结束。

// 旧方法
using (var reader = new StreamReader("file.txt"))
{
    // 使用 reader
} // reader 在这里 Dispose

// C# 8.0+ using 声明
using var reader = new StreamReader("file.txt");
using var writer = new StreamWriter("output.txt"); // 可以连续声明多个
// 使用 reader 和 writer
// ... 其他代码 ...
// reader 和 writer 会在方法/代码块结束时自动 Dispose

• 好处: 减少嵌套层级，代码更清爽。

7. LINQ 的妙用与注意事项

• Any() vs Count() > 0: 检查集合是否包含元素时，Any() 通常更高效，因为它找到第一个元素就返回，而 Count() 可能需要遍历整个集合。
• FirstOrDefault() vs First(): 如果不确定元素是否存在，使用 FirstOrDefault() 避免在找不到元素时抛出异常（它会返回默认值，通常是 null）。
• 延迟执行 (Deferred Execution): LINQ 查询通常不会立即执行，直到你迭代结果（如 foreach）或调用 ToList(), ToArray(), First(), Count() 等立即执行操作符时才执行。理解这一点对性能和逻辑很重要。
• 选择合适的集合: Where().ToList() vs 直接在 List<T>.FindAll()。有时直接使用集合提供的方法可能比通用 LINQ 更高效。

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

// 高效检查是否有偶数
bool hasEven = numbers.Any(n => n % 2 == 0);

// 安全获取第一个偶数，没有则返回 0 (int 的默认值)
int firstEvenOrDefault = numbers.FirstOrDefault(n => n % 2 == 0);

// 立即执行，获取所有偶数
List<int> evens = numbers.Where(n => n % 2 == 0).ToList();

8. nameof 操作符避免硬编码字符串

在需要引用变量名、类型名或成员名的地方（如抛出 ArgumentNullException 或实现 INotifyPropertyChanged），使用 nameof 可以在重构时自动更新名称。

public void Process(string input)
{
    if (input == null)
    {
        // 旧方法：容易出错，如果参数名改变，这里不会自动更新
        // throw new ArgumentNullException("input");
        // 使用 nameof
        throw new ArgumentNullException(nameof(input));
    }
    // ...
}

• 好处: 提高代码健壮性，易于维护。

9. ValueTuple (元组) 和解构简化多返回值

无需创建专门的 class 或 struct 就能让方法返回多个值。

// 方法返回元组
(int sum, int count) Tally(IEnumerable<int> numbers)
{
    int sum = 0;
    int count = 0;
    foreach (var n in numbers) { sum += n; count++; }
    return (sum, count); // 直接返回元组
}

// 调用并解构元组
var numbers = new[] { 1, 2, 3, 4, 5 };
(int total, int numCount) = Tally(numbers); // 解构赋值
Console.WriteLine(#34;Sum: {total}, Count: {numCount}");

// 也可以直接访问元组成员
var result = Tally(numbers);
Console.WriteLine(#34;Sum: {result.sum}, Count: {result.count}");

• 好处: 轻量级地处理多返回值场景。

10. 使用 StringBuilder 进行循环中的字符串拼接

在循环中反复使用 + 或 += 拼接字符串会产生大量临时的字符串对象，影响性能。StringBuilder 是为此优化的。

// 低效方式
string s = "";
for (int i = 0; i < 1000; i++) {
    s += i.ToString() + ","; // 每次循环都创建新字符串
}

// 高效方式
using System.Text; // 引入命名空间
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.Append(i).Append(","); // 高效追加
}
string result = sb.ToString(); // 最后生成最终字符串

• 好处: 显著提升大量字符串拼接的性能，减少内存垃圾。

11. record 类型 (C# 9.0+) 用于不可变数据对象

简化创建主要用于存储数据的不可变类型（如 DTO）。它自动提供构造函数、属性、值相等性比较 (Equals, GetHashCode) 和 ToString()。

// 定义 record
public record Person(string FirstName, string LastName);

// 或者更传统的语法，带 init-only setter
public record Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

// 使用
var person1 = new Person("John", "Doe");
var person2 = new Person("John", "Doe");

Console.WriteLine(person1); // 输出: Person { FirstName = John, LastName = Doe }
Console.WriteLine(person1 == person2); // 输出: True (值相等性比较)

// 使用 with 表达式创建副本并修改部分属性 (非破坏性突变)
var person3 = person1 with { LastName = "Smith" };
Console.WriteLine(person3); // 输出: Person { FirstName = John, LastName = Smith }

• 好处: 代码简洁，天然适合不可变数据模型，减少样板代码。

12. async/await 的正确使用

• 尽量避免 async void: 除非是事件处理器，否则 async 方法应返回 Task 或 Task<T>。async void 方法的异常难以捕获。
• 库代码中使用 ConfigureAwait(false): 在库或通用组件中，如果 await 后的代码不需要回到原始的同步上下文（如 UI 线程），使用 ConfigureAwait(false) 可以避免潜在的死锁并提高性能。
• await someAsyncTask.ConfigureAwait(false); // 后续代码将在线程池线程上执行
• 理解异步不等于多线程: async/await 主要用于 I/O 密集型操作，它释放当前线程而不是阻塞它，但不一定会创建新线程。

总结:

这些技巧覆盖了 C# 的语法糖、性能优化、代码可读性、健壮性和现代特性。熟练运用它们能让你的 C# 代码更加优雅、高效和易于维护。选择哪些技巧取决于具体的应用场景和团队规范，但了解它们总是有益的。