tccutil reset All org.godotengine.godottccutil reset All org.godotengine.godot然后 Settings -> Privacy & Security -> Full Disk Access 栏目点 + 加入 GodotSteam (或其他自编译版本)
最后，强制重新签名：
# 路径填具体对应的，这里我把 GodotSteam 放到 /Applications 里了
codesign --force --deep --sign - /Applications/GodotSteam.app]]>面向 IEEE Computer Society 期刊（重点：IEEE Transactions on Visualization and Computer Graphics, TVCG）的通用投稿流程与要求总结。
本文为 AI 总结内容，总结自：https://www.computer.org/publications/author-resources#pubs
从 这里 下载。
你将会得到一个压缩文件，你需要解压它，并获取必要文件。
我们只需要 MetaXRSimulator 文件夹。将它拷贝到你的本地机器的某处，例如 C:\MetaXRSimulator。
在 Windows 上，有两个选项可供配置当前活跃的 OpenXR 运行时：
我建议你在 IDE 或者终端里使用一个临时的环境变量 (XR_RUNTIME_JSON) 去设置当前活跃的 OpenXR 运行时，这将不会替换系统默认的 OpenXR 运行时。
设置好环境变量后，在同终端内启动你的 OpenXR 应用即可！
玩得开心！
]]>精灵 (Sprite)，在计算机图形学中指 2D 的位图，并经常使用于 2D 游戏中。
举个例子，超级马里奥中，马里奥对应的位图就是精灵。
我们如何使用 GBDK 将一个精灵绘制到 GameBoy 的屏幕中呢？
]]>精灵 (Sprite)，在计算机图形学中指 2D 的位图，并经常使用于 2D 游戏中。
举个例子，超级马里奥中，马里奥对应的位图就是精灵。
我们如何使用 GBDK 将一个精灵绘制到 GameBoy 的屏幕中呢？
答案是，使用工具，设计好我们的精灵，最后将精灵数据导出为 C 数组。
这里，我们使用最为流行的 GBTD。
如果你想造轮子
当然，自己写一个工具也是可以的，只要自己写的工具最后导出的 C 数组符合 GBDK 需要的 C 数组格式就行。
在 GameBoy 的世界中，地图多半是由瓦块所组成的瓦块地图 (Tile Map)，精灵实际上也是由一些小小的瓦块组成的。
GBTD, GameBoy Tile Designer，主要用于设计瓦块 (Tile)，并最终导出兼容 GBDK 的 C 数组。
它的界面是这样的：
关于 MacOS/Linux 运行 GBTD 和 GBMB
如果没有搭建好环境，请参考上一篇文章，先搭建好环境。
环境搭建好后，且跟着教程一起配置了 alias 后，可以直接使用别名打开：
# 打开 GBTD
gbtd
# 打开 GBMB
gbmb接下来，我们绘制一个 8*8 的笑脸，并显示在靠近屏幕中央的位置。
为什么是 8*8
GameBoy 中，精灵的渲染有两种模式（二选一）：
8*88*16每个瓦块的尺寸最小为 8*8，所以最简单的精灵都是用一个瓦块，这里我们希望精灵不要过于迷你，所以还是选择 8*8 的尺寸，实际上，1*1 都是可以的，只是依旧还是需要一个 8*8 的瓦块来表达。复杂一点的精灵，可能会使用 8*16 模式。更复杂一点的精灵，甚至可能是多个 8*8 的瓦片组合而成的。
GBTD 的最下方有一个颜色选择器。
左侧 L R 显示的是鼠标左键和鼠标右键对应要在画布上绘制的颜色索引。
右侧的四个色块代表 0 到 3 四个索引色，每个索引对应的颜色是我们自己通过调色板进行配置的，默认调色板是从白到黑的渐变的四个颜色。
GBTD 的左侧工具栏，默认选择了画笔工具，画笔底下是油漆桶工具。往下四个是移动工具，可以自行试试效果。再往下是垂直翻转、水平翻转、旋转以及自动更新。
GBTD 不存在橡皮擦工具
GBTD 不存在橡皮擦工具，这是因为 GameBoy 的颜色模式是索引色模式，而非 RGBA 模式。
如果需要擦除某个画错的部分，你要做的就是使用另一个索引色来填充画错的部分。
当我们在颜色选择器的右侧色块区域使用鼠标左键点击其中一个色块，则鼠标左键即将绘制的颜色索引会变成你点击的那个色块的索引值，简而言之就是接下来你的鼠标左键在画布上绘制的时候画笔（或油漆桶）的颜色变成了你所选色块的颜色。鼠标右键也是一样的逻辑。这样方便我们鼠标左右两个键在画布上绘制图形。
我们首先选择画笔工具，使用鼠标左键点击颜色选择器右侧的索引值为 3 的黑色色块，然后在画布上绘制一个笑脸，当然，你也可以按照自己的想法绘制，只要是 8*8 及以内的就行。
然后选择油漆桶工具，选择索引值为 1 的浅灰色色块，然后填充笑脸。
画好后大致长这样（没认真画，教程嘛，意思意思）：
绘制好了，我们就可以开始导出成 GBDK 兼容的 C 数组了。
当然，为了备份，你应该先保存一下。保存后，你将得到一个以 .gbr 后缀的文件，下次再用 GBTD 打开它就能继续编辑。
最上面主菜单点击 Files/ExportTo，然后配置如下：
关键参数介绍
Filename - 导出文件的名称，这里我们填入 Smile.c
Type - 导出数据的类型，这里我们选择 GBDK C file，代表导出文件中包含的数据是兼容 GBDK 的 C 数组
Label - 导出 C 数组的名称，我们在代码中会用到，这里我们命名为 Smile
Format - 颜色格式，这里我们选择 Gameboy 4 color
点击 OK 即可导出。导出成功后，会在 .gbr 所在同级目录下得到 Smile.h 和 Smile.c 文件。
.h 文件中是数组相关的声明，而 .c 文件中是具体定义，存放了实际的精灵数据。
下面，我们就可以利用 C 数组，开始编写程序，绘制精灵了。
相关信息
之前的 helloworld 程序由于是单文件，过于简单，所以没有提到 Visual Studio Code 的配置以及使用 Makefile。
后面的项目中，我们都会使用 Visual Studio Code + Makefile 的模式来进行开发。
我们创建一个 gb-dev 目录，并在它下面创建一个 first-sprite 目录。
然后使用 Visual Studio Code 打开 gb-dev 目录。
首先配置 includePath，让我们可以拥有智能提示。在 gb-dev 目录下创建一个 .vscode 文件夹，在该文件夹下创建一个名为 c_cpp_properties.json 的配置文件：
{
"configurations": [
{
"name": "GBDK_VSC",
"includePath": [
"${GBDKDIR}/include/**"
],
"defines": [],
"macFrameworkPath": [],
"compilerPath": "${GBDKDIR}/bin/lcc",
"cStandard": "gnu99"
}
],
"version": 4
}这样，我们以后的代码就拥有智能提示了。
然后我们将之前导出的 Smile.h 和 Smile.c 拷贝到 first-sprite 目录下。
接着我们就可以在 first-sprite 目录下，开始编写主程序 FirstSprite.c 了：
#include <gb/gb.h>
#include <stdio.h>
#include "Smile.h"
void main()
{
// 设置精灵数据
// 从第 0 号位的 Tile 开始，设置 No.0 的瓦块的数据
// 数据来源于 Smile 数组
set_sprite_data(0, 1, Smile);
// 设置精灵使用哪个瓦块的数据
// 这里是 No.0 精灵使用 No.0 瓦块数据
set_sprite_tile(0, 0);
// 一个宏，内部设置 LCDC 寄存器的第 1 位为 1，
// 目的是开启精灵层，代表显示所有精灵
SHOW_SPRITES;
// 将精灵 No.0 移动到 (84, 78) 的位置，即屏幕中央附近
move_sprite(0, 84, 78);
}set_sprite_data 的第二个参数是瓦块数量，这里只有一个瓦块，因此应传入 1。参数说明见 GBDK API 文档。
随后，我们编写一个叫做 Makefile 的文件。实际上，Makefile 是 make 的配置文件，make 可以方便我们设定编译参数以及具体每个模块的编译流程。这些模块的编译流程大多是重复的，所以使用 make 这套规则去编译，节约了我们的时间，也让编译流程更加清晰。
我们的 Makefile 如下：
# 设置 LCC 编译器执行路径
CC = $(GBDKDIR)/bin/lcc
# 设置 SameBoy 执行路径
EMU = /Applications/SameBoy.app/Contents/MacOS/SameBoy
# 默认行为，编译各个编译单元，最后链接得到 FirstSprite.gb
all:
$(CC) -Wa-l -Wl-m -Wl-j -o FirstSprite.gb Smile.c FirstSprite.c
# 编译得到 FirstSprite.gb 后，使用 SameBoy 启动
run: all
$(EMU) FirstSprite.gb
# 清理，删除中间文件和目标文件
clean:
rm -f *.o *.lst *.map *.gb *.ihx *.sym *.cdb *.adb *.asm *.noi现在，make 支持几种不同的命令参数：
FirstSprite.gb ，即 ROM 文件我们可以直接使用 make run 来编译、链接并运行。
最后的效果如下：
最后还可以使用 make clean 来删除中间文件和目标文件，回到只有源码和 Makefile 等文件的状态。
提示
gb-dev 源码看这里
我最近习惯使用 MacOS，这里我首先介绍如何在 MacOS 上搭建 GBDK 环境，并成功编译 Hello world 程序。Linux 和 MacOS 是一样的步骤。Windows 也是类似的步骤，如果有问题，欢迎随时在评论区留言。
]]>我最近习惯使用 MacOS，这里我首先介绍如何在 MacOS 上搭建 GBDK 环境，并成功编译 Hello world 程序。Linux 和 MacOS 是一样的步骤。Windows 也是类似的步骤，如果有问题，欢迎随时在评论区留言。
本文使用的版本
本文记录的是 2022 年 12 月的环境，保留了当时的版本与下载链接。新环境请根据上游发布页选择对应版本。
撰写本文时，GBDK 的稳定版本为 v4.1.1，点击直接下载。
你也可以访问这里下载最新的版本。
解压下载得到的压缩包后，我们得到一个名为 gbdk 的文件夹，其中的文件结构如下：
接下来我们需要把 gbdk 文件夹移动到一个合适的位置，并添加环境变量。
可以把该文件夹拷贝到 /opt/gbdk：
sudo cp -r gbdk /opt/gbdk然后设置相关的环境变量。
提示
为了永久生效，可以编辑 /etc/profile 或者你所使用的 shell 配置文件：
相关信息
GBDKDIR 系统环境变量是必须设置的内容，除此之外，你可以选择将 bin 目录设置到 PATH 变量中，这样我们可以更方便的使用一些预编译的可执行程序。
GBTD (GameBoy Tile Designer) 和 GBMB (GameBoy Map Builder) 分别用于瓦块设计与地图编辑。前者可以绘制精灵和瓦块，后者使用前者已绘制好的瓦块进行地图的编辑。
我们后续会用到这两个工具，这里我们先下载准备好。点击下载
最新版本在这个页面。
下载好并解压后，我们会得到 GBTD_GBMB_release 文件夹，里面包括 GBTD 文件夹和 GBMB 文件夹。
我们在 gbdk 文件夹下新建 tools 目录，然后将解压后得到的 GBTD 目录和 GBMB 目录拷贝到 tools 目录。
MacOS 和 Linux 用户可以使用 shell 来快速操作：
sudo mkdir -p $GBDKDIR/tools
cd GBTD_GBMB_release
sudo cp -r GBTD $GBDKDIR/tools/
sudo cp -r GBMB $GBDKDIR/tools/重点注意
如果工具无法保存 .ini 配置，请检查文件所有者，并仅为自己的账户授予所需的写入权限。原始步骤直接使用 chmod 777，没有必要开放给所有用户写入。若不需要系统级安装，也可以把工具放在用户自己的目录下。
提示
MacOS 和 Linux 需要准备 Wine 环境：
Wine (Wine is not an emulator, 递归式命名)，可以在 MacOS 和 Linux 上，通过本地库，链接 DLL 的形式，运行 Windows 应用。
MacOS 和 Linux 使用 Wine 运行 GBTD 和 GBMB 的后续流程
上面这些都配置好后，我们就可以这样运行 GBTD 和 GBMB：
wine $GBDKDIR/tools/GBTD/gbtd.exe
wine $GBDKDIR/tools/GBMB/gbmb.exe觉得麻烦，建议使用 alias 命令创建别名，建议写入到 /etc/profile，当然也可以跟上面配置环境变量一样，写入到 shell 的配置文件中：
# 添加到 /etc/profile
echo "alias gbtd='wine $GBDKDIR/tools/GBTD/gbtd.exe'" | sudo tee -a /etc/profile
echo "alias gbmb='wine $GBDKDIR/tools/GBMB/gbmb.exe'" | sudo tee -a /etc/profile
# 添加到 ~/.zshrc
echo "alias gbtd='wine $GBDKDIR/tools/GBTD/gbtd.exe'" | sudo tee -a ~/.zshrc
echo "alias gbmb='wine $GBDKDIR/tools/GBMB/gbmb.exe'" | sudo tee -a ~/.zshrc
# 添加到 ~/.bashrc
echo "alias gbtd='wine $GBDKDIR/tools/GBTD/gbtd.exe'" | sudo tee -a ~/.bashrc
echo "alias gbmb='wine $GBDKDIR/tools/GBMB/gbmb.exe'" | sudo tee -a ~/.bashrc由于我使用 MacOS，我考虑使用开源、跨平台的模拟器：SameBoy，它功能丰富，支持调试，方便我们开发。
打开它的下载页面，下载对应的版本即可：https://sameboy.github.io/downloads/
这里我下载 MacOS 最新 v0.15.8 版。
解压后是一个 app，拖到 应用程序 (英文系统中是 Applications) 中即可完成安装。
接下来编写我们第一个程序：在 GameBoy 的屏幕里打印一行 "Hello,world!"
helloworld.c:
#include <gb/gb.h>
#include <stdio.h>
void main()
{
printf("HELLO, WORLD!");
}在 helloworld.c 的同级目录打开命令行，并执行：
$GBDKDIR/bin/lcc -Wa-l -Wl-m -Wl-j -o helloworld.gb helloworld.c执行结束后，会发现目录下编译得到了 helloworld.gb，也就是我们熟悉的 ROM 文件啦，放到模拟器可以直接运行。
提示
可以将 SameBoy 也使用 alias 取个别名：
# 添加到 /etc/profile
echo "alias sameboy=/Applications/SameBoy.app/Contents/MacOS/SameBoy" | sudo tee -a /etc/profile
# 添加到 ~/.zshrc
echo "alias sameboy=/Applications/SameBoy.app/Contents/MacOS/SameBoy" | sudo tee -a ~/.zshrc
# 添加到 ~/.bashrc
echo "alias sameboy=/Applications/SameBoy.app/Contents/MacOS/SameBoy" | sudo tee -a ~/.bashrc然后我们就可以使用
sameboy helloworld.gb这种形式直接运行游戏了。
恭喜，到这里，你已经入门了！🎉🎉🎉
]]>现代的 GB/GBC 开发，至少需要使用高级编程语言，例如 C 语言。我们可以利用 GBDK 和 C 语言，进行 GB/GBC 开发。
GBDK (GameBoy Development Kit) 即 GameBoy 开发工具包，主要包含一个 C 语言编译器： SDCC。它包括编译器、汇编器和链接器。GBDK 还提供面向受支持硬件的库。Game Boy 使用 Sharp SM83 CPU，其指令集与 Intel 8080、Z80 有渊源，但它并不是完整的 Z80，因此不能将 Z80 代码和库与 Game Boy 代码直接互换。
]]>现代的 GB/GBC 开发，至少需要使用高级编程语言，例如 C 语言。我们可以利用 GBDK 和 C 语言，进行 GB/GBC 开发。
GBDK (GameBoy Development Kit) 即 GameBoy 开发工具包，主要包含一个 C 语言编译器： SDCC。它包括编译器、汇编器和链接器。GBDK 还提供面向受支持硬件的库。Game Boy 使用 Sharp SM83 CPU，其指令集与 Intel 8080、Z80 有渊源，但它并不是完整的 Z80，因此不能将 Z80 代码和库与 Game Boy 代码直接互换。
GBDK 包含了我们编译相关的所有内容，接下来我们开始进行环境搭建吧！
]]>前言
任天堂 GameBoy 曾是风靡全球的掌机，不过很可惜，我小时候并没有接触过它。当我长大后了解它以后，对它产生了浓厚的兴趣。我希望我可以开发一些可以在 GameBoy 上运行的游戏。
]]>前言
任天堂 GameBoy 曾是风靡全球的掌机，不过很可惜，我小时候并没有接触过它。当我长大后了解它以后，对它产生了浓厚的兴趣。我希望我可以开发一些可以在 GameBoy 上运行的游戏。
2018 年，我了解到 GBDK 这个开发工具，并利用它，和我当时已掌握的 C 语言，写过一些小游戏和 DEMO。不过那些都是半成品，就不打算展示了。
2020 年，我了解到 GB-Studio 这个让人人都能进行 GB/GBC 游戏开发的神奇工具。你并不需要编程相关的知识就可以使用它开始进行游戏创作。
2021 年，疫情期间我的创作欲比较强烈，成功使用 GB-Studio 制作了一款属于 GBC 的猫里奥：传送门
现在，我想分享一些 GB/GBC 游戏开发相关的知识，给大家带来现代的 GB/GBC 游戏开发教程系列。
对于开发工具，我打算先从比较硬核的 GBDK 开始，毕竟 GB-Studio 上手比较简单，可以放后面讲。
我并不打算先讲 GB/GBC 的硬件原理，这样过于枯燥。我会在讲开发细节的时候，介绍 GB/GBC 某个硬件模块的参数和设置，在实现效果的前提下，解释原理。
接下来你可以选择的教程：
]]>动态规划（DP）是一种通过将复杂问题分解为更小的子问题从而解决它们的方法。这是一种自下而上的方法，这意味着它从解决较小的子问题开始，然后使用这些子问题的结果去得到更大问题的结果。
要解决 DP 问题，问题必须具有以下属性：
1.最优子结构：问题的最优解可以从其子问题的最优解得到。
2.重叠的子问题：问题可以分解为多次重复使用的子问题。
举个例子，当我们计算斐波那契数列的时候，我们可以使用 DP。
提示
斐波那契数列是一系列数字，其中每个数字都是前两个数字的总和，从0和1开始。顺序如下：0、1、1、2、3、5、8、13、21、34等。该序列以比萨的莱昂纳多命名，他也被称为斐波那契。1202年，他在《Liber Abaci》一书中介绍了西欧数学的顺序。
一般而言，我们通常使用递归函数来计算斐波那契数列，就像下面这样：
int Fibonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1 || n == 2) {
return 1;
}
return Fibonacci(n - 1) + Fibonacci(n - 2);
}我们使用的技术并非 DP，而只是递归。
函数调用树存在多个节点，但是，多数节点是重复的。
我有一个公式：
DP = 递归(Recursion) + 备忘录(Memoization) 或者 制表(Tabulation) + 可选的其他改进
这是什么意思？
其实，备忘录和制表是用于提高动态规划算法性能的两种技术。
备忘录是一种技术，涉及将中间计算的结果存储在表格中，以便以后可以重复使用。这可以通过避免多次重新计算相同的子问题，帮助降低算法的整体时间复杂性。它是自上而下的。
另一方面，制表是一种涉及将所有子问题最终结果存储在表中的技术。这允许算法避免将解决方案重新计算到子问题，只需在表中查找预计算的结果。它是自下而上的。
备忘录和制表都可以用来加快动态规划算法。这两种技术之间的选择通常取决于正在解决的具体问题和可用内存量。
为了使用备忘录，我们可以定义一个查找表 (Look-up table) 或者 缓存表 (Cache table) 去保存已经计算过的结果。我们通常使用哈希表去定义该结构。
在 C++ 中，我们将使用 std::unordered_map。
举个例子，下面我们使用备忘录来解决斐波那契问题：
std::unordered_map<int, int> memo;
int Fibonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1 || n == 2) {
return 1;
}
if (memo.count(n) > 0) {
return memo[n];
} else {
memo[n] = Fibonacci(n - 1) + Fibonacci(n - 2);
}
return memo[n];
}现在，所有重复的节点都不存在了，我们只需要计算 Fibonacci(i) 一次。
我们也可以使用制表来解决这个问题。要使用制表，我们可以定义一个数组或者一个向量来保存子问题的结果。
在 C++ 中，我们将使用 std::vector。
下面是使用制表实现的 Fibonacci 函数：
int Fibonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1 || n == 2) {
return 1;
}
std::vector<int> d(n + 1);
for (int i = 3; i <= n; i++) {
d[i] = d[i - 1] + d[i - 2];
}
return d[n];
}有一种叫 "状态压缩" 的改进方式。
状态压缩是动态规划中使用的一种技术，用于减少存储计算中间结果所需的内存量。 它涉及使用较小的数据结构（如位向量或哈希表）而不是数组或矩阵等较大的数据结构来表示子问题状态。 这有助于降低算法的空间复杂性，并有可能解决更大的问题或具有更复杂的子问题的问题。
针对当前情况，我们将 d 替换为 pre 和 curr 两个整数：
int Fibonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1 || n == 2) {
return 1;
}
int pre = 1;
int curr = 1;
for (int i = 3; i <= n; i++) {
int sum = pre + curr;
pre = curr;
curr = sum;
}
return curr;
}找到所有的 base cases。
在斐波那契问题中，所有的 base cases 包括 n == 0、 n == 1 以及 n == 2。
找到所有的状态。
在斐波那契问题中，所有的状态即是所有的非负数。
找到状态转移方程。
在斐波那契问题中，状态转移方程为 : dp[i] = dp[i - 1] + dp[i - 2]
提示
状态转换方程是一个数学方程，描述了系统状态如何随时间变化。 在动态规划的背景下，状态转换方程是一种方程，它描述了如何从最优解到其子问题构建问题的最优解。 通过使用状态转换方程，可以通过将其分解为较小的子问题，然后将最优解与这些子问题相结合，以找到较大问题的最优解来解决问题。
回顾我们曾经的需求：
我们希望在泛型中进行数学运算，但是编译器无法得知 T 的运行时类型，从而无法得知 T 是否支持诸如加减乘除的数学运算，故无法实现类似下面这样的代码：
public T Add<T>(T a, T b)
{
return a + b;
}我们希望某些情况下，T 作为编译期能够确定的类型，能够调用 T 的公有静态方法。然而，接口中无法声明静态接口方法，来允许我们进行 T.XXX(); 的操作。要是能够让接口中声明静态接口方法就好了。我们曾经的幻想：
public interface ISomeInterface<T> where T : ISomeInterface<T>
{
static void SomeStaticMethod();
}
public void Test<T>() where T : ISomeInterface<T>
{
T.SomeStaticMethod();
}为了满足这些需求，微软携手社区开发者们，共同推出了静态抽象接口方法，大家以前的幻想现在已经得以实现。
静态抽象接口方法是 C# 11 (对应 .NET 7.0) 引入的新特性。使用最新的 Visual Studio 2022 版本，安装过 .NET 7.0 运行时，即可尝鲜。
它支持在接口中声明 static abstract 方法 (官方说支持在接口中声明 static virtual 方法，但我开启了 preview 后依旧报错，暂时不知道 static virtual 如何使用)。
举个例子：
我们可以利用上述新特性，定义如下接口：
public interface IGetNext<T> where T : IGetNext<T>
{
static abstract T operator ++(T other);
}许多运算符都强制要求其参数必须与类型匹配，或者是按照约束要实现包含类型的类型参数，所以这里，我们约束
T必须实现IGetNext<T>。
然后，定义一个 RepeatSequence 结构去实现上面的接口，该结构创建由 ‘A' 组成的字符串，每个 ++ 操作都使得向字符串中添加一个 'A'。
public struct RepeatSequence : IGetNext<RepeatSequence>
{
private const char Ch = 'A';
public string Text = new string(Ch, 1);
public RepeatSequence() {}
public static RepeatSequence operator ++(RepeatSequence other)
=> other with { Text = other.Text + Ch };
public override string ToString() => Text;
}然后我们可以编写测试代码，打印看看结果：
var str = new RepeatSequence();
for (int i = 0; i < 10; i++)
Console.WriteLine(str++);得到输出：
A
AA
AAA
AAAA
AAAAA
AAAAAA
AAAAAAA
AAAAAAAA
AAAAAAAAA
AAAAAAAAAA如下接口：
public interface IDeepInSourceCode<T> where T : IDeepInSourceCode<T>
{
void SomeMethod();
static abstract void SomeStaticAbstractMethod();
}它的 IL：
// Type: StaticAbstractInterfaceMethods.IDeepInSourceCode`1
// Assembly: StaticAbstractInterfaceMethods, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 27A20D9E-C658-48F7-8AC2-47D46316D62D
// Location: F:\static_abstract\StaticAbstractInterfaceMethods\bin\Debug\net7.0\StaticAbstractInterfaceMethods.dll
// Sequence point data from f:\static_abstract\staticabstractinterfacemethods\bin\debug\net7.0\staticabstractinterfacemethods.pdb
.class interface public abstract auto ansi
StaticAbstractInterfaceMethods.IDeepInSourceCode`1<(class StaticAbstractInterfaceMethods.IDeepInSourceCode`1<!0/*T*/>) T>
{
.param constraint [1] /*T*/, class StaticAbstractInterfaceMethods.IDeepInSourceCode`1<!0/*T*/>
.custom instance void System.Runtime.CompilerServices.NullableAttribute::.ctor([in] unsigned int8)
= (01 00 01 00 00 ) // .....
// unsigned int8(1) // 0x01
.method public hidebysig virtual newslot abstract instance void
SomeMethod() cil managed
{
// Can't find a body
} // end of method IDeepInSourceCode`1::SomeMethod
.method public hidebysig static virtual abstract void
SomeStaticAbstractMethod() cil managed
{
// Can't find a body
} // end of method IDeepInSourceCode`1::SomeStaticAbstractMethod
} // end of class StaticAbstractInterfaceMethods.IDeepInSourceCode`1对比发现，实际上，static abstract 方法和普通接口方法的区别在于，newslot 和 instance 关键字变成了 static。
这意味着，实现 static abstract 接口方法的具体实现方法，必须是一个以 `public static 开头的方法。
接着上面的接口，我们定义两个类型：
public class DeepInSourceCodeBase : IDeepInSourceCode<DeepInSourceCodeBase>
{
public virtual void SomeMethod()
{
Console.WriteLine("SomeMethodBase is invoked.");
}
public static void SomeStaticAbstractMethod()
{
Console.WriteLine("SomeStaticAbstractMethodBase is invoked.");
}
}
public class DeepInSourceCodeDerived : DeepInSourceCodeBase, IDeepInSourceCode<DeepInSourceCodeDerived>
{
public override void SomeMethod()
{
Console.WriteLine("SomeMethodDerived is invoked.");
}
public new static void SomeStaticAbstractMethod()
{
Console.WriteLine("SomeStaticAbstractMethodDerived is invoked.");
}
}DeepInSourceCodeBase 实现了 IDeepInSourceCode<DeepInSourceCodeBase> 接口。
DeepInSourceCodeDerived 派生自 DeepInSourceCodeBase，重写了 SomeMethod 方法，覆盖了 SomeStaticAbstractMethod 方法。
写一个测试代码：
public class DeepInSourceCodeTester
{
public static void Test<T1, T2>()
where T1 : IDeepInSourceCode<T1>, new()
where T2 : T1, new()
{
T1 t1 = new T1();
T2 t2 = new T2();
t1.SomeMethod();
t2.SomeMethod();
T1.SomeStaticAbstractMethod();
T2.SomeStaticAbstractMethod();
}
}在 Main 方法中加入测试代码：
internal class Program
{
static void Main(string[] args)
{
DeepInSourceCodeTester.Test<DeepInSourceCodeBase, DeepInSourceCodeDerived>();
}
}先猜猜结果是什么？
SomeMethodBase is invoked.
SomeMethodDerived is invoked.
SomeStaticAbstractMethodBase is invoked.
SomeStaticAbstractMethodDerived is invoked.你会猜测是这样的结果吗？
其实不是。
这里结果是：
SomeMethodBase is invoked.
SomeMethodDerived is invoked.
SomeStaticAbstractMethodBase is invoked.
SomeStaticAbstractMethodBase is invoked.官方有专门的说明：https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interface#static-abstract-and-virtual-members
当我们把 where T2 : T1, new() 改为 where T2 : IDeepInSourceCode<T2>, new() 结果就是我们猜测的那样了。
为了支持泛型数学，.NET 7.0 将所有的基元类型进行了重新实现。
以 Int32 为例，它现在要实现更多的接口，这些接口就是为了进行一些泛型数学运算。
public readonly struct Int32
: IComparable,
IConvertible,
ISpanFormattable,
IComparable<int>,
IEquatable<int>,
IBinaryInteger<int>,
IMinMaxValue<int>,
ISignedNumber<int>Int32 除了之前实现的一些接口，目前还实现了以下新的接口：
IBinaryInterger<int>
public interface IBinaryInteger<TSelf>
: IBinaryNumber<TSelf>,
IShiftOperators<TSelf, int, TSelf>
where TSelf : IBinaryInteger<TSelf>?IBinaryNumber<int>
public interface IBinaryNumber<TSelf>
: IBitwiseOperators<TSelf, TSelf, TSelf>,
INumber<TSelf>
where TSelf : IBinaryNumber<TSelf>?IBitwiseOperators<int, int, int>
声明了重载 &、|、~、! 四个运算符的 static abstract 方法
INumber<int>
public interface INumber<TSelf>
: IComparable,
IComparable<TSelf>,
IComparisonOperators<TSelf, TSelf, bool>,
IModulusOperators<TSelf, TSelf, TSelf>,
INumberBase<TSelf>
where TSelf : INumber<TSelf>?IComparisonOperators<int, int, int>
声明了重载 >、<、>=、<= 四个运算符的 static abstract 方法
IModulusOperators<int, int, int>
声明了重载 % 运算符的 static abstract 方法
INumberBase<int>
public interface INumberBase<TSelf>
: IAdditionOperators<TSelf, TSelf, TSelf>,
IAdditiveIdentity<TSelf, TSelf>,
IDecrementOperators<TSelf>,
IDivisionOperators<TSelf, TSelf, TSelf>,
IEquatable<TSelf>,
IEqualityOperators<TSelf, TSelf, bool>,
IIncrementOperators<TSelf>,
IMultiplicativeIdentity<TSelf, TSelf>,
IMultiplyOperators<TSelf, TSelf, TSelf>,
ISpanFormattable,
ISpanParsable<TSelf>,
ISubtractionOperators<TSelf, TSelf, TSelf>,
IUnaryPlusOperators<TSelf, TSelf>,
IUnaryNegationOperators<TSelf, TSelf>
where TSelf : INumberBase<TSelf>?简述：主要声明了四则运算相关运算符的重载 static abstract 方法。
IShiftOperators<int, int, int>
声明了重载 <<、>>、>>> 三个移位运算符的 static abstract 方法
IMinMaxValue<int>
声明了 MinValue、MaxValue 两个 static abstract 属性，表示具有最大最小值属性。
ISignedNumber<int>
声明了 NegativeOne static abstract 属性，表示具有 -1 属性。
如此一来，Int32 可以作为泛型数学的泛型参数。
除了 Int32，其他诸如 Single、Double、Byte 这些基元类型也都实现了很多这种用于泛型数学运算的接口。
举一个简单的例子：
public static void MultiplyAndSub<T>(T t1, T t2, T t3)
where T : IMultiplyOperators<T, T, T>, ISubtractionOperators<T, T, T>
{
Console.WriteLine(t1 * t2 - t3);
}上述方法约束 T 类型支持乘法和减法运算。
可以这样调用上述方法：
MultiplyAndSub(1, 2, 3);
MultiplyAndSub(0.1f, 0.2f, 0.3f);
MultiplyAndSub(0.1d, 0.2d, 0.3d);当然，我们也可以自己定义一个类型，然后实现 乘法、减法 相关的接口：
public struct MultiplyAndSubCustomStruct :
IMultiplyOperators<MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct>,
ISubtractionOperators<MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct>
{
public MultiplyAndSubCustomStruct(int value)
{
Value = value;
}
public int Value;
public static MultiplyAndSubCustomStruct operator *(MultiplyAndSubCustomStruct left, MultiplyAndSubCustomStruct right)
{
return new MultiplyAndSubCustomStruct(left.Value * right.Value);
}
public static MultiplyAndSubCustomStruct operator -(MultiplyAndSubCustomStruct left, MultiplyAndSubCustomStruct right)
{
return new MultiplyAndSubCustomStruct(left.Value - right.Value);
}
public string ToString(string? format, IFormatProvider? formatProvider)
{
return Value.ToString(format, formatProvider);
}
}然后也可以调用 MultiplyAndSub：
MultiplyAndSub(new MultiplyAndSubCustomStruct(1), new MultiplyAndSubCustomStruct(2), new MultiplyAndSubCustomStruct(3));结果是 -1，符合预期。
为了提高我的英文写作能力，我决定，后续发布的大多数文章都会有中英两个版本。
]]>为了提高我的英文写作能力，我决定，后续发布的大多数文章都会有中英两个版本。
]]>为了解决这个问题，我们需要创建一个名为 AutoIncrementIdCollection 的新集合，其中我们插入一些有两个字段的模型（AutoIncrementIdModel）：
每次在将新的索引模型 M 插入集合 C 之前，我们都会找到一个 CollectionName 为 C 的 AutoIncrementIdModel，并将其序列加一，然后使用该序列创建 M（M 的 id 字段由序列初始化）并将其插入 C。
]]>