C# 8.0 新语法的学习和使用

C# 8.0 是微软在 2019 年 9 月 23 日随 .NET Core 3.0 一同发布的一个重要版本更新，带来了许多新的语言特性和改进。本文将详细介绍 C# 8.0 的新语法，并通过实际应用案例展示这些新特性的使用方法。

[1. 可空引用类型](#1. 可空引用类型)

[2. 异步流](#2. 异步流)

[3. 默认接口方法](#3. 默认接口方法)

[4. 模式匹配增强](#4. 模式匹配增强)

[5. 索引和范围](#5. 索引和范围)

[6. 只读成员](#6. 只读成员)

[7. Switch 表达式](#7. Switch 表达式)

[8. 空合并赋值 (Null-Coalescing Assignment)](#8. 空合并赋值 (Null-Coalescing Assignment))

1. 可空引用类型

C# 8.0 引入了可空引用类型，以减少因 null 引用导致的异常。这项功能通过静态分析，可以帮助我们识别和修复潜在的 NullReferenceException 问题。

cs 复制代码

#nullable enable

public class Person
{
    public string Name { get; set; }
    public string? Address { get; set; }
}

public void Example()
{
    Person person = new Person { Name = "John" };
    Console.WriteLine(person.Name.Length); // 安全访问
    Console.WriteLine(person.Address?.Length); // 安全访问，可为空
}

在上述代码中，Name 是非空的引用类型，编译器会确保在任何情况下 Name 都不会为 null。而 Address 则是可空的引用类型，使用时需要进行 null 检查。

2. 异步流

异步流通过引入 IAsyncEnumerable<T> 接口，使得我们可以在异步方法中使用 yield return 来生成异步流，方便地处理异步数据流。

cs 复制代码

public async IAsyncEnumerable<int> GenerateNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(1000);
        yield return i;
    }
}

public async Task ConsumeAsync()
{
    await foreach (var number in GenerateNumbersAsync())
    {
        Console.WriteLine(number);
    }
}

在这个例子中，GenerateNumbersAsync 方法异步生成一个整数流，ConsumeAsync 方法异步消费这个流。

3. 默认接口方法

默认接口方法允许在接口中提供方法的默认实现，使得接口的扩展更加容易而不破坏现有实现。

cs 复制代码

public interface ILogger
{
    void Log(string message);

    void LogError(string message)
    {
        Log($"Error: {message}");
    }
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public class Program
{
    public static void Main()
    {
        ILogger logger = new ConsoleLogger();
        logger.Log("This is a log message.");
        logger.LogError("This is an error message.");
    }
}

4. 模式匹配增强

C# 8.0 增强了模式匹配功能，引入了 switch 表达式、位置模式和属性模式，使得代码更加简洁和可读。

cs 复制代码

public static string DescribeShape(object shape) => shape switch
{
    Circle c => $"Circle with radius {c.Radius}",
    Rectangle r => $"Rectangle with width {r.Width} and height {r.Height}",
    _ => "Unknown shape"
};

public class Circle
{
    public double Radius { get; set; }
}

public class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
}

public static void Main()
{
    object shape = new Circle { Radius = 5 };
    Console.WriteLine(DescribeShape(shape)); // 输出 "Circle with radius 5"
}

5. 索引和范围

新的索引和范围语法使得操作数组和集合更加简洁和直观。

cs 复制代码

public static void Main()
{
    int[] numbers = { 1, 2, 3, 4, 5 };

    Console.WriteLine(numbers[^1]); // 输出 5，获取最后一个元素
    var subArray = numbers[1..4]; // 获取子数组，从索引1到索引4（不包括4）
    
    foreach (var number in subArray)
    {
        Console.WriteLine(number); // 输出 2, 3, 4
    }
}

6. 只读成员

在结构体中声明只读成员，可以确保这些成员不会修改结构体的状态。

cs 复制代码

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public readonly double Distance => Math.Sqrt(X * X + Y * Y);
}

public static void Main()
{
    Point p = new Point(3, 4);
    Console.WriteLine(p.Distance); // 输出 5
}

7. Switch 表达式

switch 表达式提供了一种更加简洁和功能强大的模式匹配语法。

cs 复制代码

public static string GetDayName(DayOfWeek day) => day switch
{
    DayOfWeek.Monday => "Monday",
    DayOfWeek.Tuesday => "Tuesday",
    DayOfWeek.Wednesday => "Wednesday",
    DayOfWeek.Thursday => "Thursday",
    DayOfWeek.Friday => "Friday",
    DayOfWeek.Saturday => "Saturday",
    DayOfWeek.Sunday => "Sunday",
    _ => throw new ArgumentOutOfRangeException()
};

public static void Main()
{
    DayOfWeek today = DayOfWeek.Wednesday;
    Console.WriteLine(GetDayName(today)); // 输出 "Wednesday"
}

8. 空合并赋值 (Null-Coalescing Assignment)

空合并赋值运算符 ??= 使得在变量为 null 时赋值更加简便。

cs 复制代码

public static void Main()
{
    string? name = null;
    name ??= "default";
    Console.WriteLine(name); // 输出 "default"
}

C# 8.0 引入的这些新特性大大的我们能够编写更高效、更易维护的代码。从可空引用类型到异步流，再到模式匹配和默认接口方法，这些改进不仅提高了开发体验，还提升了代码的安全性和可读性。在实际开发中，合理使用这些新特性，可以帮助我们写出更优雅、更可靠的程序。