.NET8 正式发布， C#12 新变化

.NET8 正式发布，C#12 新变化探索

在 .NET Conf 2023 大会上，.NET 8 正式闪亮登场，并且它还是一个长期支持（LTS）版本，这意味着开发者们在未来三年都能获得稳定的支持和补丁。如果大家想要使用 .NET 8 ，可以在这个地址下载相关的 SDK：https://dotnet.microsoft.com/zh-cn/download/dotnet/8.0 ，当然也可以把 VS2022 升级到 17.8 版本。

.NET 8 在很多方面都有显著增强，像人工智能、云原生、性能、native AOT 等领域。不过，咱们今天重点关注 C# 语言和一些框架层面的新变化。全部的更新说明可以查看官方文档：https://learn.microsoft.com/zh-cn/dotnet/core/whats-new/dotnet-8 。

一、序列化增强

1. 其他类型的内置支持

在 .NET 8 中，序列化功能有了很大的改进。它现在可以对 Half、Int128、UInt128 这些附加类型进行序列化。在 .NET 7 里，对这些类型序列化虽然不会报错，但无法正常获取内容。同时，还支持对 ReadOnlyMemory 和 Memory 类型进行序列化。当 T 的类型为 byte 时，序列化结果是 base64 格式，否则就是 json 数组。

下面是示例代码：

csharp 复制代码

using System.Text.Json;
// 输出：[65500,170141183460469231731687303715884105727,340282366920938463463374607431768211455]
Console.WriteLine(JsonSerializer.Serialize(new object[] { Half.MaxValue, Int128.MaxValue, UInt128.MaxValue }));
// 输出："AQIDBAUG"
Console.WriteLine(JsonSerializer.Serialize<ReadOnlyMemory<byte>>(new byte[] { 1, 2, 3, 4, 5, 6 }));
// 输出：[1,2,3]
Console.WriteLine(JsonSerializer.Serialize<Memory<int>>(new int[] { 1, 2, 3 }));

这些改进让开发者在处理更多类型的数据序列化时更加方便，无需再为特殊类型的序列化问题而烦恼。

2. 接口层次结构

在之前的版本（3.1、6、7）中，当使用包含多个属性的接口来接收对象实例化并进行序列化时，继承过来的属性可能无法被识别。而在 .NET 8 中，这个问题得到了很好的解决。

示例代码如下：

csharp 复制代码

IDerived value = new DerivedImplement { Base = 0, Derived = 1 };
Console.WriteLine(JsonSerializer.Serialize(value));
// 输出：{"Base":0,"Derived":1}

public interface IBase
{
    public int Base { get; set; }
}

public interface IDerived : IBase
{
    public int Derived { get; set; }
}

public class DerivedImplement : IDerived
{
    public int Base { get; set; }
    public int Derived { get; set; }
}

不过需要注意的是，如果之前使用了一些变通方式来处理这个问题，在升级到 .NET 8 后，一定要进行针对性的测试和调整。

3. 命名策略

在之前的版本中，序列化时命名策略只支持 CamelCase 。而在 .NET 8 中，新增了多种命名策略，比如：

KebabCaseLower：小写中划线，例如：user-name
KebabCaseUpper：大写中划线，例如：USER-NAME
SnakeCaseLower：小写下划线，例如：user_name
SnakeCaseUpper：大写下划线，例如：USER_NAME

示例代码：

csharp 复制代码

var options1 = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.KebabCaseLower,
};
var options2 = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.KebabCaseUpper,
};
var options3 = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
};
var options4 = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseUpper,
};
Console.WriteLine(JsonSerializer.Serialize(new UserInfo() { UserName = "oec2003" }, options1));
Console.WriteLine(JsonSerializer.Serialize(new UserInfo() { UserName = "oec2003" }, options2));
Console.WriteLine(JsonSerializer.Serialize(new UserInfo() { UserName = "oec2003" }, options3));
Console.WriteLine(JsonSerializer.Serialize(new UserInfo() { UserName = "oec2003" }, options4));

public class UserInfo
{
    public string? UserName { get; set; }
}

这些新增的命名策略为开发者在序列化时提供了更多的选择，能更好地满足不同的业务需求。

4. 调用 API 直接获取到对象

在 .NET 8 之前的版本中，如果要获取接口数据，需要先获取接口内容，然后进行反序列化。而在 .NET 8 中，可以直接调用 GetFromJsonAsAsyncEnumerable 方法直接得到对象，无需进行反序列化操作。

以下是对比代码：
.NET 8 之前的版本：

csharp 复制代码

const string RequestUri = "http://localhost:5145/user";
using var client = new HttpClient();
var stream = await client.GetStreamAsync(RequestUri);
// 反序列化
var users = JsonSerializer.DeserializeAsyncEnumerable<UserInfo>(stream);
await foreach (UserInfo user in users)
{
    Console.WriteLine($"姓名：{user.userName}");
}
Console.ReadKey();

public record UserInfo(string userName);

.NET 8 版本：

csharp 复制代码

const string RequestUri = "http://localhost:5145/user";
using var client = new HttpClient();
IAsyncEnumerable<UserInfo> users = client.GetFromJsonAsAsyncEnumerable<UserInfo>(RequestUri);

await foreach (UserInfo user in users)
{
    Console.WriteLine($"姓名： {user.userName}");
}
Console.ReadKey();

public record UserInfo(string userName);

这种改进大大简化了代码逻辑，提高了开发效率。

二、随机数增强

1. GetItems() 方法

在 .NET 8 中，随机数类 Random 新增了 GetItems() 方法，它可以根据指定的数量在提供的一个集合中随机抽取数据项，生成一个新的集合。

示例代码：

csharp 复制代码

ReadOnlySpan<string> colors = new[] { "Red", "Green", "Blue", "Black" };

string[] t1 = Random.Shared.GetItems(colors, 10);
Console.WriteLine(JsonSerializer.Serialize(t1));
// 输出每次都会不一样，例如：["Black","Green","Blue","Blue","Green","Blue","Green","Black","Green","Blue"]
Console.ReadKey();

这个方法在一些需要随机抽取数据的场景中非常实用，比如抽奖系统等。

2. Shuffle() 方法

通过 Random 提供的 Shuffle() 方法，可以将一个集合中的数据项的顺序打乱。

示例代码：

csharp 复制代码

string[] colors = new[] { "Red", "Green", "Blue", "Black" };
Random.Shared.Shuffle(colors);

Console.WriteLine(JsonSerializer.Serialize(colors));
Console.ReadKey();

这个方法在游戏开发、数据随机排序等场景中会有很好的应用。

三、新增的提高性能的类型

1. FrozenDictionary<TKey,TValue> 和 FrozenSet

.NET 8 新增了 FrozenDictionary<TKey,TValue> 和 FrozenSet 这两个类型，它们位于 System.Collections.Frozen 命名空间下。创建这两种类型的集合后，就不允许对键和值进行任何更改，因此可以实现更快的读取操作。

下面是使用 BenchmarkDotNet 对 FrozenDictionary 和 Dictionary 进行测试的代码：

csharp 复制代码

BenchmarkRunner.Run<FrozenDicTest>();
Console.ReadKey();

[SimpleJob(RunStrategy.ColdStart, iterationCount: 5)]
public class FrozenDicTest
{
    public static Dictionary<string, string> dic = new()
    {
        { "name1", "oec2003" },
        { "name2", "oec2004" },
        { "name3", "oec2005" }
    };

    public static FrozenDictionary<string, string> fdic = dic.ToFrozenDictionary();

    [Benchmark]
    public void TestDic()
    {
        for (int i = 0; i < 100000000; i++)
        {
            dic.TryGetValue("name", out _);
        }
    }

    [Benchmark]
    public void TestFDic()
    {
        for (int i = 0; i < 100000000; i++)
        {
            fdic.TryGetValue("name", out _);
        }
    }
}

从测试结果可以明显看出，FrozenDictionary 的读取性能有很大提升。这对于一些对读取性能要求较高的场景，如缓存系统等，是非常有帮助的。

2. System.Buffers.SearchValues 类

新增的 System.Buffers.SearchValues 类，可以用来进行字符串的查找和匹配，相比较 string 类型的操作，性能有大幅提升。

下面是使用 BenchmarkDotNet 进行测试的代码：

csharp 复制代码

BenchmarkRunner.Run<SearchValuesTest>();
Console.ReadKey();

[SimpleJob(RunStrategy.ColdStart, iterationCount: 5)]
public class SearchValuesTest
{
    [Benchmark]
    public void TestString()
    {
        var str = "!@#$%^&*()_1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        for (int i = 0; i < 100000000; i++)
        {
            str.Contains("z");
        }
    }

    [Benchmark]
    public void TestSearchValues()
    {
        var sv = SearchValues.Create("!@#$%^&*()_1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"u8);
        byte b = (byte)"z"[0];
        for (int i = 0; i < 100000000; i++)
        {
            sv.Contains(b);
        }
    }
}

从运行结果来看，性能大约有 5 倍的提升。这对于需要频繁进行字符串查找和匹配的场景，如文本处理、日志分析等，能显著提高程序的运行效率。

四、依赖注入增强

在 .NET 8 之前的版本中，如果一个接口有多个实现类，依赖注入的写法比较繁琐，只能获取到最后一个注册类的实例。而在 .NET 8 中，添加了注入关键字，可以很方便地实现一个接口多个实现类的注入。

.NET 8 之前的版本：

csharp 复制代码

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddTransient<IUser, UserA>();

var app = builder.Build();

app.MapGet("/user", (IUser user) =>
{
    return $"hello , {user.GetName()}";
});

app.Run();

internal interface IUser
{
    string GetName();
}
internal class UserA : IUser
{
    public string GetName() => "oec2003";
}

.NET 8 版本：

csharp 复制代码

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddKeyedSingleton<IUser, UserA>("A");
builder.Services.AddKeyedSingleton<IUser, UserB>("B");

var app = builder.Build();

app.MapGet("/user1", ([FromKeyedServices("A")] IUser user) =>
{
    return $"hello , {user?.GetName()}";
});
app.MapGet("/user2", ([FromKeyedServices("B")] IUser user) =>
{
    return $"hello , {user?.GetName()}";
});

app.Run();

internal interface IUser
{
    string GetName();
}
internal class UserA : IUser
{
    public string GetName() => "oec2003";
}
internal class UserB : IUser
{
    public string GetName() => "oec2004";
}

这种改进让依赖注入的使用更加灵活，降低了代码的耦合度，提高了代码的可维护性。

总的来说，.NET 8 和 C# 12 的这些新变化为开发者带来了更多的便利和更好的性能，大家可以在实际项目中尝试使用，体验这些新特性带来的魅力。 ======================================================================

前些天发现了一个比较好玩的人工智能学习网站，通俗易懂，风趣幽默，可以了解了解AI基础知识，人工智能教程，不是一堆数学公式和算法的那种，用各种举例子来学习，读起来比较轻松，有兴趣可以看一下。
人工智能教程