百度360必应搜狗淘宝本站头条
mqtt服务器xftp6vscode使用技巧mybatiscollectionkeyerror
当前位置：网站首页 > 热门文章 > 正文

C#12 中集合表达式的介绍

bigegpt 2024-09-08 11:26 6 浏览

经典集合初始化器

自 C# 3.0 起，我们就有了 “集合初始化器” 。它们采用 {} 模式来初始化任何实现了 Add() 方法的 IEnumerable 实现。例如，这会创建一个新的 List<string> 并用 5 个值初始化它：

var values = new List<string> { "1", "2", "3", "4", "5" };

幕后，编译器生成的代码看起来像这样：

List<string> values = new List<string>();
values.Add("1");
values.Add("2");
values.Add("3");
values.Add("4");
values.Add("5");

C# 中的数组初始化有其特别之处，你可以用比其他集合更多的方法来初始化它们，尽管看起来与标准集合初始化器相似：

var values1 = new[] { "1", "2", "3", "4" };
var values2 = new string[4] { "1", "2", "3", "4" };
string[] values3 = { "1", "2", "3", "4" };

这些工作方式与集合初始化器不同；这里没有调用 Add() 方法。相反，编译器生成的是如果你手动做这一切时同样的初始化代码：

string[] array = new string[4];
array[0] = "1";
array[1] = "2";
array[2] = "3";
array[3] = "4";

我们已经讨论了通用集合（如 List ）和数组的集合初始化器，还有在 Span 世界中变得更为有用的 stackalloc 表达式，因为不需要使用 unsafe 代码：

Span<int> array = stackalloc []{ 1, 2, 3, 4 };

幕后，编译器将这个 stackalloc 初始化器转化为一些类似这样的 unsafe 代码：

unsafe {
    byte* num = stackalloc byte[16];
    *(int*)num = 1;
    *(int*)(num + 4) = 2;
    *(int*)(num + (nint)2 * (nint)4) = 3;
    *(int*)(num + (nint)3 * (nint)4) = 4;
    Span<int> array = new Span<int>(num, 4);
}

这段代码在栈上创建了一个数组，然后通过指针运算遍历每个元素，设置每个值。

使用集合表达式统一语法

我们已经看到至少有三种不同的场景下我们在初始化集合：

  • 数组
  • 类似 List 的集合
  • 使用 stackalloc 的 ReadOnlySpan

每种情况都需要稍微不同的语法，例如：

int[] array = new[] { 1, 2, 3, 4 };
List<int> list = new() { 1, 2, 3, 4 };
HashSet<int> hashset = new() { 1, 2, 3, 4 };
ReadOnlySpan<int> span = stackalloc [] { 1, 2, 3, 4 };

这有点混乱和烦人。C#12 中引入的集合表达式提供了一种简化、统一的语法，适用于所有这些不同的集合类型。例如：

int[] array = [1, 2, 3, 4]
List<int> list = [1, 2, 3, 4];
HashSet<int> hashset = [1, 2, 3, 4];
ReadOnlySpan<int> span = [1, 2, 3, 4];

集合表达式在所有集合类型上的一致性是一个真正的优势，但这并不是唯一的优点。集合表达式相比集合初始化器可以提供性能优势（我们将在后续文章中探讨），以及额外的功能。

推断接口类型

想象一下，你想要创建一个集合，但你只关心它实现了 IEnumerable 。你需要自己决定使用哪个后端类型：

IEnumerable<int> list1 = new List<int> { 1, 2, 3, 4 };
IEnumerable<int> list2 = new HashSet<int> { 1, 2, 3, 4 };
IEnumerable<int> list3 = new int[] { 1, 2, 3, 4 };

那么应该选择哪一个呢？如果所有你需要做的就是枚举列表，那理论上选择哪种类型都不应该重要，对吧？那么正确的选项是什么？

使用集合表达式，你可以将此决策委托给编译器。你可以不指定后端类型，而由编译器来决定。而且，集合表达式的额外优点是更加简洁：

IEnumerable<int> ienumerable = [1, 2, 3, 4];
IList<int> ilist = [1, 2, 3, 4];
IReadOnlyCollection<int> icollection = [1, 2, 3, 4];

幕后，编译器完全透明地创建了一个实现所需接口的集合，所以你无需考虑这一点。

值得注意的是，虽然编译器会自动为接口集合选择一个具体的类型，但你需要指定某种类型。例如，你不能使用 var ：

var values = [1, 2, 3, 4]; // ? 编译错误，CS9176：集合表达式没有目标类型
Sum(values);
Sum([1, 2, 3, 4]); // ? 这是可行的
int Sum(IEnumerable<int> v) => v.Sum();

问题在于，根据 C#编译器的工作方式，它无法推断 values 的类型应为 IEnumerable<int> ，因此抛出了错误。未来版本的 C#可能会改变这种情况，但可能的解决方案是始终选择 int[] ，这并不一定是最优的，所以不要抱太大希望。

针对ReadOnlySpan的高效自动stackalloc

对于 ReadOnlySpan 和 Span 实例来说，如果你只使用集合初始化器，情况也类似。如果你只需要在 Span 或 ReadOnlySpan 中存储一些数据，那么使用集合初始化器就需要决定将数据放在哪里，然后再从中获取 Span：

Span<int> spans2 = stackalloc[] { 1, 2, 3, 4 }; // 栈上分配数组
Span<int> spans3 = new[] { 1, 2, 3, 4 }; // 在堆上分配
Span<string> spans4 = new[] { "1", "2", "3", "4" }; // 不能直接使用 stackalloc 分配字符串数组

虽然这不是一个很大的决策，通常只有两个合理的选择，但还是需要额外考虑的事情。此外，你不能直接使用 stackalloc 为 string[] 分配内存，除非通过一些 InlineArray 的技巧 。

使用集合表达式，你可以再次将此决策委托给编译器，它会做出正确的处理。

ReadOnlySpan<int> readonlyspans = [1, 2, 3, 4];
Span<string> spans = ["1", "2", "3", "4"];

在系列的后续部分，你会发现这些特定的集合表达式案例被高度优化！

集合表达式使重构更简单

到目前为止，我展示的所有例子都是将集合表达式赋值给变量，但实际上你也可以直接将集合表达式作为方法参数使用，比如：

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

// 创建一个接受IEnumerable<int>的方法
int Sum(IEnumerable<int> values) => values.Sum();

// 使用集合表达式调用方法
Sum([1, 2, 3, 4]);

这种模式的一个好处是，如果我改变了 Sum() 的签名，我不需要改变调用站点。相比之下，如果你使用集合初始化器：

// 如果方法接受数组...
int Sum1(int[] values) => values.Sum();
Sum1(new [] { 1, 2, 3, 4 }); // 必须使用数组语法

// 如果方法接受IEnumerable...
int Sum2(IEnumerable<int> values) => values.Sum();
Sum2(new List<int> { 1, 2, 3, 4 }); // 必须使用显式类型，如List或类似

// 如果方法接受ReadOnlySpan...
int Sum3(ReadOnlySpan<int> values) {
    var total = 0;
    foreach (var value in values) {
        total += value;
    }
    return total;
}
Sum3(new []{ 1, 2, 3, 4 }); // 必须选择标准数组或者使用stackalloc分配的数组

如果使用集合表达式，那么我们可以使用完全相同的语法来调用所有三个 Sum() 实现：

Sum1([ 1, 2, 3, 4 ]); Sum2([ 1, 2, 3, 4 ]); Sum3([ 1, 2, 3, 4 ]);

并且，编译器会使用最有效的实现方式来创建所需类型的集合。

这看起来可能是一件小事，而且在某种程度上确实是这样，但正是所有这些小小的便利特性使得集合表达式成为一个非常整洁的功能！整体而言，正是这些微小的方便性让集合表达式的使用变得极为顺手和高效。

空集合

在 C# 中，集合表达式的一个特性是编译器明确识别空集合的语法。这意味着你不再需要写像下面这样的代码：

var empty = new int[]{}; // 通常你不应该这样做...
var empty = Array.Empty<int>(); // ...相反，更倾向于使用这行代码!

现在，你可以使用 [] 来生成一个适当的空集合版本，例如：

int[] empty = [];

集合表达式相比于显式初始化有两大主要优势：

  • 编译器可以选择创建空集合的最有效方式，比如选择 Array.Empty()（或其等价方法）。
  • 对于所有集合类型，你可以使用一致的语法。

以下示例展示了多种集合类型，以及如何使用 [] 来创建它们的空版本。每行代码后的注释显示了编译器为特定类型生成的代码：

int[] array = []; // Array.Empty()
HashSet<int> hashset = []; // new HashSet<int>()
List<int> list = []; // new List<int>()
IEnumerable<int> ienumerable = []; // Array.Empty()
ICollection<int> icollection = []; // new List<int>()
IList<int> ilist = []; // new List<int>()
IReadOnlyCollection<int> readonlycollection = []; // Array.Empty()
IReadOnlyList<int> readonlyList = []; // Array.Empty()
Span<int> span = []; // default(Span<int>)
ReadOnlySpan<int> readonlyspan = []; // default(ReadOnlySpan<int>)
ImmutableArray<int> immutablearray = []; // ImmutableArray.CreateRange(Array.Empty())
ImmutableList<int> immutablelist = []; // ImmutableList.Create(default(ReadOnlySpan<int>));

如你所见，编译器尽可能地高效；如果类型是可变的，如 HashSet 或 List，那么它只能创建一个新的实例；但如果可以使用不分配内存的版本，如 Array.Empty()，那么它就会采用这种方式！请注意，在最后一个示例中，ImmutableArray 和 ImmutableList 使用了不同的构造函数来创建空集合，因为它们是不可变集合。

使用展开运算符（spread element）从其他集合构建集合

我们已经了解了集合表达式的两个好处：

  • 一致的语法
  • 高效的编译器生成实现

集合表达式的另一个重要特性是 展开运算符 (..)。这使你能够更容易地从其他集合实例构建新的集合。

举个具体的例子，假设你有两个 IEnumerable 集合，并且你想将它们作为数组连接起来。使用 LINQ，这是相当容易做到的，因为它提供了专门用于此类操作的扩展方法：

int[] ConcatAsArray(IEnumerable<int> first, IEnumerable<int> second)
{
    return first.Concat(second).ToArray();
}

很好，但是如果现在你需要处理的是 ReadOnlySpan 而不是 IEnumerable 呢？不幸的是，正如我们之前讨论的那样，ReadOnlySpan 不实现 IEnumerable 接口，所以我们可能需要这样做：

int[] ConcatAsArray(ReadOnlySpan<int> first, ReadOnlySpan<int> second)
{
    var list = new List<int>(first.Length + second.Length);
    list.AddRange(first);
    list.AddRange(second);
    return list.ToArray();
}

这虽然不是 糟糕，但仍然让人感到恼火，因为对于每种不同的集合类型都得考虑这些细节。而使用集合表达式和展开运算符，我们得到了一个简洁的快捷方式，它可以用于所有受支持的集合类型。上述两种重载都可以用同样的方式实现：

int[] ConcatAsArray(IEnumerable<int> first, IEnumerable<int> second) => [..first, ..second];
int[] ConcatAsArray(ReadOnlySpan<int> first, ReadOnlySpan<int> second) => [..first, ..second];

而且，由于集合表达式的一致性，如果你更改 ConcatAsArray() 方法的参数 或者 返回类型，你完全不需要修改集合表达式本身，它依旧可以正常工作！

.. 运算符意味着 “写出集合中的所有值” ，因此再举一个例子：

int[] array = [1, 2, 3, 4];
IEnumerable<int> oddValues = array.Where(int.IsOddInteger); // 1, 3
int[] evenValues = [..array.Where(int.IsEvenInteger)];      // 2, 4
int[] allValues = [..oddValues, ..evenValues];             // 1, 3, 2, 4

上述代码多次使用了展开运算符，但在每种情况下，它都意味着 “写出集合的所有元素” 。所以在最后一步中，allValues 包含了 oddValues 中的所有元素，后面跟着 evenValues 中的所有值。

你也可以在集合表达式中混合单一值和展开集合，例如：

int[] arr = [1, 2, 3, 4];
int[] myValues = [0, ..arr, 5, 6]; // 0, 1, 2, 3, 4, 5, 6

最终结果就像是遍历了 arr 并添加了每个值一样。

注意，展开运算符 .. 与 范围运算符（如 1..3 或 2..^ 中的 ..）是 不同 的，后者用于对数组进行 索引。然而，你可以结合使用它们，先用 范围 来选择元素子集，然后将它们 展开 到集合表达式中：

int[] primes = [1, 2, 3, 5, 7, 9, 11];
int[] some = [0, ..primes[1..^1]]; // 0, 2, 3, 5, 7, 9

这段代码使用 1..^1 范围运算符取 primes 数组的第1个至N-1个元素（即 2, 3, 5, 7, 9），然后在集合表达式中使用展开 ..。

集合表达式为创建集合添加了一种很好的对称性（在重构从一种集合类型到另一种时特别有用），并且通过展开运算符使集合的组合变得更加简单。但集合表达式不仅仅是关于语法。重要的是，集合表达式为编译器提供了优化其生成代码的选项。

相关推荐

Redis集群对比:主从复制、哨兵模式、Cluster一文看懂所有优缺点

在分布式系统中，Redis作为高性能的内存数据库，其集群方案的选择直接影响到系统的稳定性、可用性和扩展性。本文将全面对比Redis的三种主流集群方案：主从复制、哨兵模式和Cluster模式，帮助开发者...

redis的主从复制，读写分离，主从切换

当数据量变得庞大的时候，读写分离还是很有必要的。同时避免一个redis服务宕机，导致应用宕机的情况，我们启用sentinel(哨兵)服务，实现主从切换的功能。redis提供了一个master,多个sl...

# Redis 入门到精通(九)-- 主从复制(3)

#Redis入门到精通（九）--主从复制（3）##一、redis主从复制-常见问题（1）###1、伴随着redis系统的运行，master的数据量会越来越大，一旦master重启...

redis - 主从复制（Redis主从复制时序图）

1引言在上一篇文章中，我们了解了Redis两种不同的持久化方式，Redis服务器通过持久化，把Redis内存中持久化到硬盘当中，当Redis宕机时，我们重启Redis服务器时，可以由RDB文件或AO...

# Redis 入门到精通(九)-- 主从复制(2)

#Redis入门到精通（九）--主从复制（2）##一、redis主从复制--数据同步阶段注意事项###1、数据同步阶段master说明1）如果master数据量巨大，数据同步阶段应...

Redis主从复制（redis主从复制主节点挂了）

介绍Redis有两种不同的持久化方式，Redis服务器通过持久化，把Redis内存中持久化到硬盘当中，当Redis宕机时，我们重启Redis服务器时，可以由RDB文件或AOF文件恢复内存中的数据。不过...

深入解析 Redis 集群的主从复制实现方式

在互联网大厂的后端开发领域，Redis作为一款高性能的内存数据库，被广泛应用于缓存、消息队列等场景。而Redis集群中的主从复制机制，更是保障数据安全、实现读写分离以及提升系统性能的关键所在。今...

Redis主从架构详解（redis主从架构高可用如何实现）

Redis主从架构搭建Redis主节点配置创建主节点目录（/opt/redis-master），复制redis.conf到该目录下，redis.conf配置项修改#后台启动daemonizeyes...

抖音“四大包塘战神”:承包了全网的快乐

在抖音钓鱼垂类领域，"包塘战神"军团正掀起一场黑色幽默风暴。空军华、大表坑、李赔光、透心良四位创作者，以承包鱼塘为舞台，用连续翻车的钓鱼直播构筑起流量奇观。当钓鱼佬在抖音集体转型喜剧人...

ORACLE 11G RAC 安装-通过VM配置共享磁盘

简介：在自己的电脑上通过VM软件搭建Oracle11GRAC，通过修改VM的参数文件来实现磁盘共享！目标：搭建RAC环境实现：使用VMwareWorkstation8.0.0+ORACLE...

Linux操作系统安全配置（linux系统安全配置包括）

一、服务相关命令systemctlenable服务名#开机自启动systemctldisable服务名#禁用开机自启动systemctlstop服务名#停止服务systemctls...

关于Linux性能调优中网络I/O的一些笔记

写在前面和小伙伴分享一些Linux网络优化的笔记,内容很浅，可以用作入门博文内容结合《Linux性能优化》读书笔记整理涉及内容包括常用的优化工具(mii-tool,ethtool,ifconfig,i...

从 Sonatype Nexus Repository Manager 迁移到 Artifactory

1.Nexus1.1下载下载链接：https://help.sonatype.com/repomanager3/product-information/download/download-archiv...

Ubuntu20安装zabbix5.0企业监控系统亲测教程

前言示例主机：zabbix10.0.100.10，将安装在UbuntuServer上教程说明：因使用官方教程无法安装成功，所以本教程与官方教程有所不同安装前提：已安装UbuntuServer2...

Linux内核设计与实现—进程管理（linux内核程序设计）

进程进程就是处于执行期的程序(目标码存放在某种存储介质上)。进并不仅仅局限于一段可执行程序代码(Unix称其为代码段，textsection)。通常进程还要包含其他资源，像打开的文件，挂起的信号，...

一周热门
最近发表
标签列表