如何用C#编写一个小于8KB的贪吃蛇游戏

01/18/2023 14:54:22 | China Standard Time

这篇文章是作为一个实验而出现的，目的是找出一个有用的自包含运行时的C#可执行文件可以有多小。C#应用程序能否达到用户会认为瞬间就能下载完毕的大小？它是否能使C#被用于现在还没有被使用的场景？

> 译者注：这是Michal Strehovský大佬的一篇文章，他目前在微软.NET Runtime团队工作，主要是负责.NET NativeAOT功能的开发。我在前几天看到这篇文章，非常喜欢，虽然它的内容稍微有点过时(还是使用的.NET Core 3.0)，不过其中的一些编程技巧和思维方式很受用，特意找到Michal大佬要到了授权，翻译给大家看。

[]()

> 作者：Michal Strehovský
原文链接：[https://medium.com/MStrehovsky/building-a-self-contained-game-in-c-under-8-kilobytes-74c3cf60ea04](https://medium.com/MStrehovsky/building-a-self-contained-game-in-c-under-8-kilobytes-74c3cf60ea04)
译者：InCerry
译文链接:  [https://www.cnblogs.com/InCerry/p/building-a-self-contained-game-in-c-under-8-kilobytes-74c3cf60ea04.html](https://www.cnblogs.com/InCerry/p/building-a-self-contained-game-in-c-under-8-kilobytes-74c3cf60ea04.html)

作为一个在1.44MB软盘和56kbit调制解调器时代长大的人，我一直喜欢小程序。我可以在随身携带的软盘上装下许多小程序。如果一个程序不能放在我的软盘上，我就开始思考为什么-它有大量的图形吗？有音乐吗？这个程序能做很多复杂的事情吗？还是它根本就是臃肿的？

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/7f301bcc-a4b3-4c69-b4ca-0c3817ffe1e6.jpg)

图片来自 [Brett Jordan Unsplash](https://unsplash.com/@brett_jordan?utm_source=medium&utm_medium=referral)

现在，磁盘空间变得如此便宜（巨大的闪存盘无处不在），人们放弃了对程序大小的优化。

有一个场景的大小仍然很重要，那就是传输：当在线路上传输一个程序时，每秒只能传递兆字节的数据。一个快速的100MBit连接在最好的情况下每秒只能传输12MB。如果在线路的另一端是一个等待下载完成的人，五秒和一秒之间的差异会对他们的体验产生很大的影响。

此人可能直接（用户通过网络下载程序）或间接（部署Severless服务以响应 Web 请求）暴露在传输时间中。

人们通常认为任何快于0.1秒的东西都是即时的，3.0秒大约是用户的流量保持不间断的极限，而你很难在10秒后让用户保持参与。

> 虽然更小一点程序不再是必须的，但它仍然是更好的。

这篇文章是作为一个实验而出现的，目的是找出一个有用的自包含运行时的C#可执行文件可以有多小。C#应用程序能否达到用户会认为瞬间就能下载完毕的大小？它是否能使C#被用于现在还没有被使用的场景？

# 究竟什么是 “自包含”?

一个自包含的应用程序是指包括在操作系统的虚构安装上运行所需的一切。

C#编译器属于一组以虚拟机为目标的编译器（Java和Kotlin是该组的另一个知名的语言）：C#编译器的输出是一个可执行文件，需要某种虚拟机（VM）来执行。人们不能只安装一个裸机操作系统，并期望能够在上面运行由C#编译器产生的程序。

至少在Windows上，过去人们可以依靠在整个机器上安装.NET Framework来运行C#编译器的输出。现在，有许多Windows SKU不再携带.NET Framework（物联网、Nano Server、ARM64......）。.NET Framework也不支持C#语言的最新增强功能。它有点像在走下坡路。

为了使C#应用程序自成一体，它需要包括运行时和它使用的所有类库。在我们的计划中，要把很多东西装进只有8KB的预算中！这是很重要的。

# 8KB的游戏

我们要创建一个克隆版的贪吃蛇游戏，下面是完成后的演示:

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/d39374b2-21c4-4502-a428-d98cf5e1ca1e.jpg)

如果你对游戏机制不感兴趣，请随意跳到有趣的部分，我们在9个步骤中将游戏从65MB缩小到8KB（向下滚动到你看到图形的地方）。

游戏将在文本模式下运行，我们将使用框画字符来画蛇。我相信Vulcan或DirectX会更有趣，但我们会用`System.Console`来搞定。

# 一个无分配的游戏

我们将建立一个无分配的游戏 - 我所说的无分配并不是指C#游戏开发者中常见的 "不要在游戏循环中分配"。我的意思是 "在整个代码库中禁止使用引用类型的`new`关键字"。其原因将在缩小游戏的最后阶段变得明显。

有了这样的限制，人们可能会想，使用C#到底有没有意义：没有`new`关键字，我们就不会使用垃圾收集器，我们就不能抛出异常，等等 - 像C语言一样，也可以工作。

使用C#的一个原因是 "因为我们可以"。另一个原因是可测试性和代码共享 - 虽然游戏整体上是无分配的，但这并不意味着它的一部分不能在没有这种限制的不同项目中重复使用。例如，游戏的部分内容可以包含在xUnit项目中，以获得单元测试覆盖。如果选择C语言来构建游戏，那么即使代码从其他地方被重用，事情也必须受到C语言所能做到的限制。但由于C#提供了高水平和低水平结构的良好组合，我们可以遵循"默认为高水平，必要时为低水平(译者注：也就是说C#语言下限很低，上限很高的意思，99%的情况可以直接编写简单的高抽象的代码，1%的情况可以直接写类似C++低级代码)"的哲学。

为了达到8KB的部署大小，低级别的部分将是必要的。

# 游戏结构

让我们从一个表示帧缓冲器的`结构体`开始。帧缓冲器是一个组件，用来保存要绘制到屏幕上的像素（或者在这里是字符）：

```csharp
unsafe struct FrameBuffer
{
	public const int Width = 40;
	public const int Height = 20;
	public const int Area = Width * Height;

	fixed char _chars[Area];

	public void SetPixel(int x, int y, char character)
	{
		_chars[y * Width + x] = character;
	}

	public void Clear()
	{
		for (int i = 0; i < Area; i++)
		_chars[i] = ' ';
	}

	public readonly void Render()
	{
		Console.SetCursorPosition(0, 0);

		const ConsoleColor snakeColor = ConsoleColor.Green;

		Console.ForegroundColor = snakeColor;

		for (int i = 1; i <= Area; i++)
		{
			char c = _chars[i - 1];

			if (c == '*' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
			{
				Console.ForegroundColor = c == '*' ? ConsoleColor.Red : ConsoleColor.White;
				Console.Write(c);
				Console.ForegroundColor = snakeColor;
			}
			else
				Console.Write(c);

			if (i % Width == 0)
			{
				Console.SetCursorPosition(0, i / Width - 1);
			}
		}
	}
}
```

我们提供了一些方法来设置各个像素，清除帧缓冲区，并将帧缓冲区的内容渲染到`System.Console`中。渲染步骤对几个字符进行了特殊处理，这样我们就可以得到彩色的输出，而不需要对帧缓冲区的每个像素进行颜色跟踪。

需要指出的一个有趣的事情是`fixed _chars[Area]`字段：这是C#的语法，用于声明一个[固定数组](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/unsafe-code-pointers/fixed-size-buffers)。固定数组是一个数组，其各个元素是结构的一部分。您可以将其视为一组字段`char _char_0, _char_1, _char_2, _char_3,...`的快捷方式。`_char_Area`，可以作为一个数组访问。这个数组的大小需要是一个编译时的常数，以便整个结构的大小是固定的。

我们不能过分追求固定数组的大小，因为作为结构的一部分，数组需要住在堆栈中，而堆栈往往被限制在很小的字节数内（通常每个线程1MB）。但是，`40*20*2字节（width*height*sizeof(char)）`应该没问题。

接下来我们需要的是一个随机数发生器。.NET自带的随机数发生器是一个引用类型（有很好的理由！），我们禁止自己使用`new`关键字 , 我们不能使用它。一个简单的结构就可以了。

```csharp
struct Random
{
    private uint _val;

    public Random(uint seed)
    {
        _val = seed;
    }

    public uint Next() => _val = (1103515245 * _val + 12345) % 2147483648;
}
```

这个随机数发生器不是很好，但我们不需要任何复杂的东西。

现在，我们只需要一些东西来包装蛇的逻辑。是时候建立一个 "蛇"结构了。

```csharp
struct Snake
{
    public const int MaxLength = 30;

    private int _length;

    // 身体是一个打包的整数，打包了X坐标、Y坐标和字符。
    // 为蛇的身体。
    // 只有原始类型可以使用C#的`固定`，因此这是一个`int`。
    private unsafe fixed int _body[MaxLength];

    private Direction _direction;
    private Direction _oldDirection;

    public Direction Course
    {
        set
        {
            if (_oldDirection != _direction)
                _oldDirection = _direction;

            if (_direction - value != 2 && value - _direction != 2)
                _direction = value;
        }
    }

    public unsafe Snake(byte x, byte y, Direction direction)
    {
        _body[0] = new Part(x, y, DirectionToChar(direction, direction)).Pack();
        _direction = direction;
        _oldDirection = direction;
        _length = 1;
    }

    public unsafe bool Update()
    {
        Part oldHead = Part.Unpack(_body[0]);
        Part newHead = new Part(
            (byte)(_direction switch
            {
                Direction.Left => oldHead.X == 0 ? FrameBuffer.Width - 1 : oldHead.X - 1,
                Direction.Right => (oldHead.X + 1) % FrameBuffer.Width,
                _ => oldHead.X,
            }),
            (byte)(_direction switch
            {
                Direction.Up => oldHead.Y == 0 ? FrameBuffer.Height - 1 : oldHead.Y - 1,
                Direction.Down => (oldHead.Y + 1) % FrameBuffer.Height,
                _ => oldHead.Y,
            }),
            DirectionToChar(_direction, _direction)
            );

        oldHead = new Part(oldHead.X, oldHead.Y, DirectionToChar(_oldDirection, _direction));

        bool result = true;

        for (int i = 0; i < _length - 1; i++)
        {
            Part current = Part.Unpack(_body[i]);
            if (current.X == newHead.X && current.Y == newHead.Y)
                result = false;
        }

        _body[0] = oldHead.Pack();

        for (int i = _length - 2; i >= 0; i--)
        {
            _body[i + 1] = _body[i];
        }

        _body[0] = newHead.Pack();

        _oldDirection = _direction;

        return result;
    }

    public unsafe readonly void Draw(ref FrameBuffer fb)
    {
        for (int i = 0; i < _length; i++)
        {
            Part p = Part.Unpack(_body[i]);
            fb.SetPixel(p.X, p.Y, p.Character);
        }
    }

    public bool Extend()
    {
        if (_length < MaxLength)
        {
            _length += 1;
            return true;
        }
        return false;
    }

    public unsafe readonly bool HitTest(int x, int y)
    {
        for (int i = 0; i < _length; i++)
        {
            Part current = Part.Unpack(_body[i]);
            if (current.X == x && current.Y == y)
                return true;
        }

        return false;
    }

    private static char DirectionToChar(Direction oldDirection, Direction newDirection)
    {
        const string DirectionChangeToChar = "│┌?┐┘─┐??└│┘└?┌─";
        return DirectionChangeToChar[(int)oldDirection * 4 + (int)newDirection];
    }

    // 帮助结构来打包和解压_body中打包的整数。
    readonly struct Part
    {
        public readonly byte X, Y;
        public readonly char Character;

        public Part(byte x, byte y, char c)
        {
            X = x;
            Y = y;
            Character = c;
        }

        public int Pack() => X << 24 | Y << 16 | Character;
        public static Part Unpack(int packed) => new Part((byte)(packed >> 24), (byte)(packed >> 16), (char)packed);
    }

    public enum Direction
    {
        Up, Right, Down, Left
    }
}
```

蛇需要跟踪的状态是。代表蛇的身体的每个像素的坐标：
- 蛇的当前长度。
- 蛇的当前方向。
- 蛇的过去方向（以备我们需要画 "弯 "字而不是直线）。

蛇提供了一些方法来"延长"蛇的长度（如果蛇已经长到一定长度则返回false），用蛇的身体来 "测试"一个像素，"绘制"蛇到一个 "FrameBuffer"中，以及"更新"蛇的位置，作为对游戏tick的响应（如果蛇吃了自己则返回false）。还有一个属性用于设置蛇的当前"路线"。

我们使用与帧缓冲区相同的固定数组技巧来保持蛇的无分配。这意味着蛇的最大长度必须是一个编译时常数。

我们需要的最后一件事是游戏循环:

```csharp
struct Game
{
    enum Result
    {
        Win, Loss
    }

    private Random _random;

    private Game(uint randomSeed)
    {
        _random = new Random(randomSeed);
    }

    private Result Run(ref FrameBuffer fb)
    {
        Snake s = new Snake(
            (byte)(_random.Next() % FrameBuffer.Width),
            (byte)(_random.Next() % FrameBuffer.Height),
            (Snake.Direction)(_random.Next() % 4));

        MakeFood(s, out byte foodX, out byte foodY);

        long gameTime = Environment.TickCount64;

        while (true)
        {
            fb.Clear();

            if (!s.Update())
            {
                s.Draw(ref fb);
                return Result.Loss;
            }

            s.Draw(ref fb);

            if (Console.KeyAvailable)
            {
                ConsoleKeyInfo ki = Console.ReadKey(intercept: true);
                switch (ki.Key)
                {
                    case ConsoleKey.UpArrow:
                        s.Course = Snake.Direction.Up; break;
                    case ConsoleKey.DownArrow:
                        s.Course = Snake.Direction.Down; break;
                    case ConsoleKey.LeftArrow:
                        s.Course = Snake.Direction.Left; break;
                    case ConsoleKey.RightArrow:
                        s.Course = Snake.Direction.Right; break;
                }
            }

            if (s.HitTest(foodX, foodY))
            {
                if (s.Extend())
                    MakeFood(s, out foodX, out foodY);
                else
                    return Result.Win;
            }

            fb.SetPixel(foodX, foodY, '*');

            fb.Render();

            gameTime += 100;

            long delay = gameTime - Environment.TickCount64;
            if (delay >= 0)
                Thread.Sleep((int)delay);
            else
                gameTime = Environment.TickCount64;
        }
    }

    void MakeFood(in Snake snake, out byte foodX, out byte foodY)
    {
        do
        {
            foodX = (byte)(_random.Next() % FrameBuffer.Width);
            foodY = (byte)(_random.Next() % FrameBuffer.Height);
        }
        while (snake.HitTest(foodX, foodY));
    }

    static void Main()
    {
        Console.SetWindowSize(FrameBuffer.Width, FrameBuffer.Height);
        Console.SetBufferSize(FrameBuffer.Width, FrameBuffer.Height);
        Console.Title = "See Sharp Snake";
        Console.CursorVisible = false;

        FrameBuffer fb = new FrameBuffer();

        while (true)
        {
            Game g = new Game((uint)Environment.TickCount64);
            Result result = g.Run(ref fb);

            string message = result == Result.Win ? "You win" : "You lose";

            int position = (FrameBuffer.Width - message.Length) / 2;
            for (int i = 0; i < message.Length; i++)
            {
                fb.SetPixel(position + i, FrameBuffer.Height / 2, message[i]);
            }

            fb.Render();

            Console.ReadKey(intercept: true);
        }
    }
}
```

我们使用随机数发生器生成蛇的随机位置和方向，我们随机地将食物放在游戏表面，确保它不与蛇重叠，然后开始游戏循环。

在游戏循环中，我们要求蛇更新它的位置并检查它是否吃了自己。然后我们画出蛇，检查键盘的输入，用食物对蛇进行测试，并将所有内容渲染到控制台。

这就差不多了。让我们看看我们在尺寸方面的情况。

# .NET Core 3.0 贪吃蛇的大小

我把游戏放在[GitHub repo](https://github.com/MichalStrehovsky/SeeSharpSnake)中，这样你就可以跟着做了。该项目文件将根据传递给`publish`的`Mode`属性，以不同的配置制作游戏。要用CoreCLR生成默认配置，请运行：

```bash
dotnet publish -r win-x64 -c Release
```

这将产生一个单一的EXE文件，其容量高达65MB。产生的EXE包括游戏、.NET运行时和作为.NET标准部分的基础类库。你可能会说 "仍然比Electron好"，但让我们看看我们是否能做得更好。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/46f26f94-7cb7-47a7-8ab4-badec3ca9b1a.jpg)

# IL Linker

IL Linker是一个随.NET Core 3.0出厂的工具 - 该工具通过扫描整个程序并删除未被引用的程序集来删除你的应用程序中未使用的代码。要在项目中使用它，需要传递一个`PublishTrimmed`属性来发布。像这样：

```bash
dotnet publish -r win-x64 -c Release /p:PublishTrimmed=true
```

在这种设置下，游戏缩减到25MB。这是一个很好的开端，带来了60%的缩减，但离我们10KB的目标还很远。

IL Linker有更积极的设置，但没有公开，它们可以进一步降低这个数字，最终，我们将受到CoreCLR运行时本身coreclr.dll(5.3MB的限制)。我们可能已经在通往8KB游戏的道路上走到了死胡同。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/b75a03bd-46df-4540-af00-46f2684d6ebf.jpg)

# 曲线救国: Mono

[Mono](https://www.mono-project.com/)是另一个.NET运行时，对很多人来说是Xamarin的同义词。为了用C#贪吃蛇构建一个可执行文件，我们可以使用Mono自带的mkbundle工具。

```bash
mkbundle SeeSharpSnake.dll --simple -o SeeSharpSnake.exe
```

这将产生一个12.3MB的可执行文件，它依赖于mono-2.0-sgen.dll，它本身有5.9MB - 所以我们看到总共有18.2MB。当试图启动它时，我碰到了 "错误的映射文件：`mono_file_map_error`失败"，但是除了这个错误之外，还会有其它问题，mono最终的结果是18.2 MB。

与CoreCLR不同，Mono还依赖于Visual C++运行时再分配库，而该库在默认的Windows安装中是不可用的：为了保持应用程序自成一体的目标，我们需要将该库与应用程序一起携带。这使应用程序的占用空间又增加了一兆字节左右。

我们有可能通过添加IL链接器来缩小体积，但我们会遇到与CoreCLR相同的问题-运行时（mono-2.0-sgen.dll）的大小为5.9MB（加上它上面的C++运行时库的大小），它代表了任何可能的IL级优化可能带给我们的底限。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/0acebd5e-b1bc-4f48-bc49-b170e1f20fe4.jpg)

# 我们可以把运行时拿掉吗？

很明显，为了达到接近8KB的目标，我们需要把运行时从应用程序中剥离出来。唯一可以做到这一点的.NET运行时是[CoreRT](https://github.com/dotnet/corert)。虽然人们通常称CoreRT为"运行时"，但它更接近于一个"运行时库"。它不是像CoreCLR或Mono那样的虚拟机 - CoreRT的运行时只是一组函数，支持由CoreRT的AOT编译器产生的本地代码。

CoreRT自带的库使CoreRT看起来像其他的.NET运行时：有一个添加GC的库，添加支持反射的库，添加JIT的库，添加解释器的库，等等。但所有这些库都是可选的（包括GC）。

更多关于CoreRT与CoreCLR和Mono的不同之处在[这篇文章](https://medium.com/@MStrehovsky/fight-the-global-warming-compile-your-c-apps-ahead-of-time-9997e953645b)。当我在阅读[D语言](https://theartofmachinery.com/2017/06/04/what_is_the_d_runtime.html)的运行时间时，它让我想起了CoreRT的很多内容。这篇文章也是一个有趣的阅读。

让我们看看我们在默认的CoreRT配置下的情况:

```bash
dotnet publish -r win-x64 -c Release /p:Mode=CoreRT
```

这降到了4.7MB。这是迄今为止最小的，但仍然不够好。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/ccaab6db-c76b-4d3c-b4c2-5709ac7a7aac.jpg)

# 在CoreRT中设置节省级别为中等

CoreRT-AOT编译器提供了[大量](http://aka.ms/OptimizeCoreRT)影响代码生成的设置。默认情况下，编译器试图以牺牲生成的可执行文件的大小为代价，最大限度地提高生成代码的速度和与其他.NET运行机制的兼容性。

编译器有一个内置的链接器，可以删除未使用的代码。我们在Snake项目中定义的 "CoreRT-Moderate "设置放宽了对删除未使用代码的一个限制，允许更多的删除。我们还要求编译器用程序速度换取一些额外的字节。大多数.NET程序在这种模式下都能正常工作。

```bash
dotnet publish -r win-x64 -c Release /p:Mode=CoreRT-Moderate
```

现在是4.3 MB。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/4d874bef-7c37-4a90-9648-1be03bf51cdf.jpg)

# 在CoreRT中设置节省级别为高

我把另外几个编译选项归纳为"高"模式。这个模式将删除对许多会影响到应用程序的东西的支持，但Snake（作为低级别的东西）不会有问题。

我们将删除：
- 框架实施细节的堆栈跟踪数据
- 框架产生的异常中的异常信息
- 对非英语区的支持
- EventSource工具化

```bash
dotnet publish -r win-x64 -c Release /p:Mode=CoreRT-High
```

我们已经达到了3.0MB。这是我们开始时的5%，但CoreRT还有一招。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/e69c3be9-dc34-4b17-af75-a9b6c552ab08.jpg)

# 关闭反射

CoreRT运行时库的很大一部分是用于实现.NET的反射。因为CoreRT是一个提前编译的基于运行时库的.NET实现，它不需要典型的基于虚拟机的运行时（如CoreCLR和Mono）需要的大部分数据结构。这些数据包括诸如类型、方法、签名、基础类型等的名称。CoreRT嵌入这些数据是因为使用.NET反射的程序需要它，但不是因为运行时需要它。我把这些数据称为 "反射开销"，因为它对运行时来说就是这样的。

CoreRT支持一种[无反射模式](https://github.com/dotnet/corert/blob/master/Documentation/using-corert/reflection-free-mode.md)，可以避免这种开销。你可能会觉得很多.NET代码在没有反射的情况下无法工作，你可能是对的，但有很多东西确实可以工作，令人惊讶。Gui.cs、System.IO.Pipelines，甚至是一个基本的WinForms应用程序。贪吃蛇肯定会工作，所以让我们把这个模式打开。

```bash
dotnet publish -r win-x64 -c Release /p:Mode=CoreRT-ReflectionFree
```

我们现在是1.2MB。反映反射开销是相当大的!

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/56e2d21e-fe27-49f0-b7ba-039279f91d9e.jpg)

# 来点骚操作

现在我们已经走到了.NET SDK可能实现的尽头，我们需要来点骚操作。我们现在要做的事情已经开始变得很荒谬了，我不指望其他人能做到这一点。我们要依靠CoreRT编译器和运行时的实现细节。

正如我们前面所看到的，CoreRT是一套运行时库，加上一个超前的编译器。如果我们用一个最小的重新实现来取代运行时库呢？我们已经决定不使用垃圾收集器，这使得这项工作更加可行。

让我们从简单的事情开始：

```csharp
namespace System.Threading
{
    static class Thread
    {
        [DllImport("api-ms-win-core-synch-l1-2-0")]
        public static extern void Sleep(int delayMs);
    }
}

namespace System
{
    static class Environment
    {
        [DllImport("api-ms-win-core-sysinfo-l1-1-0")]
        private static extern long GetTickCount64();

        public static long TickCount64 => GetTickCount64();
    }
}
```

在这里我们重新实现了`Thread.Sleep`和`Environment.TickCount64`（用于Windows），同时避免了对现有运行时库的所有依赖。

让我们对游戏使用的`System.Console`子集做同样的事情：

```csharp
namespace System
{
    static class Console
    {
        private enum BOOL : int
        {
            FALSE = 0,
            TRUE = 1,
        }

        [DllImport("api-ms-win-core-processenvironment-l1-1-0")]
        private static unsafe extern IntPtr GetStdHandle(int c);

        private readonly static IntPtr s_outputHandle = GetStdHandle(-11);

        private readonly static IntPtr s_inputHandle = GetStdHandle(-10);

        [DllImport("api-ms-win-core-console-l2-1-0.dll", EntryPoint = "SetConsoleTitleW")]
        private static unsafe extern BOOL SetConsoleTitle(char* c);
        public static unsafe string Title
        {
            set
            {
                fixed (char* c = value)
                    SetConsoleTitle(c);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        struct CONSOLE_CURSOR_INFO
        {
            public uint Size;
            public BOOL Visible;
        }

        [DllImport("api-ms-win-core-console-l2-1-0")]
        private static unsafe extern BOOL SetConsoleCursorInfo(IntPtr handle, CONSOLE_CURSOR_INFO* cursorInfo);

        public static unsafe bool CursorVisible
        {
            set
            {
                CONSOLE_CURSOR_INFO cursorInfo = new CONSOLE_CURSOR_INFO
                {
                    Size = 1,
                    Visible = value ? BOOL.TRUE : BOOL.FALSE
                };
                SetConsoleCursorInfo(s_outputHandle, &cursorInfo);
            }
        }

        [DllImport("api-ms-win-core-console-l2-1-0")]
        private static unsafe extern BOOL SetConsoleTextAttribute(IntPtr handle, ushort attribute);

        public static ConsoleColor ForegroundColor
        {
            set
            {
                SetConsoleTextAttribute(s_outputHandle, (ushort)value);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct KEY_EVENT_RECORD
        {
            public BOOL KeyDown;
            public short RepeatCount;
            public short VirtualKeyCode;
            public short VirtualScanCode;
            public short UChar;
            public int ControlKeyState;
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct INPUT_RECORD
        {
            public short EventType;
            public KEY_EVENT_RECORD KeyEvent;
        }

        [DllImport("api-ms-win-core-console-l1-2-0", EntryPoint = "PeekConsoleInputW", CharSet = CharSet.Unicode)]
        private static unsafe extern BOOL PeekConsoleInput(IntPtr hConsoleInput, INPUT_RECORD* lpBuffer, uint nLength, uint* lpNumberOfEventsRead);

        public static unsafe bool KeyAvailable
        {
            get
            {
                uint nRead;
                INPUT_RECORD buffer;
                while (true)
                {
                    PeekConsoleInput(s_inputHandle, &buffer, 1, &nRead);

                    if (nRead == 0)
                        return false;

                    if (buffer.EventType == 1 && buffer.KeyEvent.KeyDown != BOOL.FALSE)
                        return true;

                    ReadConsoleInput(s_inputHandle, &buffer, 1, &nRead);
                }
            }
        }

        [DllImport("api-ms-win-core-console-l1-2-0", EntryPoint = "ReadConsoleInputW", CharSet = CharSet.Unicode)]
        private static unsafe extern BOOL ReadConsoleInput(IntPtr hConsoleInput, INPUT_RECORD* lpBuffer, uint nLength, uint* lpNumberOfEventsRead);

        public static unsafe ConsoleKeyInfo ReadKey(bool intercept)
        {
            uint nRead;
            INPUT_RECORD buffer;
            do
            {
                ReadConsoleInput(s_inputHandle, &buffer, 1, &nRead);
            }
            while (buffer.EventType != 1 || buffer.KeyEvent.KeyDown == BOOL.FALSE);

            return new ConsoleKeyInfo((char)buffer.KeyEvent.UChar, (ConsoleKey)buffer.KeyEvent.VirtualKeyCode, false, false, false);
        }

        struct SMALL_RECT
        {
            public short Left, Top, Right, Bottom;
        }

        [DllImport("api-ms-win-core-console-l2-1-0")]
        private static unsafe extern BOOL SetConsoleWindowInfo(IntPtr handle, BOOL absolute, SMALL_RECT* consoleWindow);

        public static unsafe void SetWindowSize(int x, int y)
        {
            SMALL_RECT rect = new SMALL_RECT
            {
                Left = 0,
                Top = 0,
                Right = (short)(x - 1),
                Bottom = (short)(y - 1),
            };
            SetConsoleWindowInfo(s_outputHandle, BOOL.TRUE, &rect);
        }

        [StructLayout(LayoutKind.Sequential)]
        struct COORD
        {
            public short X, Y;
        }

        [DllImport("api-ms-win-core-console-l2-1-0")]
        private static unsafe extern BOOL SetConsoleScreenBufferSize(IntPtr handle, COORD size);

        public static void SetBufferSize(int x, int y)
        {
            SetConsoleScreenBufferSize(s_outputHandle, new COORD { X = (short)x, Y = (short)y });
        }

        [DllImport("api-ms-win-core-console-l2-1-0")]
        private static unsafe extern BOOL SetConsoleCursorPosition(IntPtr handle, COORD position);

        public static void SetCursorPosition(int x, int y)
        {
            SetConsoleCursorPosition(s_outputHandle, new COORD { X = (short)x, Y = (short)y });
        }

        [DllImport("api-ms-win-core-console-l1-2-0", EntryPoint = "WriteConsoleW")]
        private static unsafe extern BOOL WriteConsole(IntPtr handle, void* buffer, int numChars, int* charsWritten, void* reserved);

        public static unsafe void Write(char c)
        {
            int dummy;
            WriteConsole(s_outputHandle, &c, 1, &dummy, null);
        }
    }
}
```

让我们用这个替换框架重建游戏：

```bash
dotnet publish -r win-x64 -c Release /p:Mode=CoreRT-ReflectionFree /p:IncludePal=true
```

不出所料，这并没有为我们节省多少。我们要替换的API已经是相对轻量级的了，重写它们只获得了几千字节，不值得一提。但这是通往我们旅程中最后一步的重要垫脚石。

# 替换所有的运行时库

在Snake游戏中剩下的1.2MB的代码和数据是用来支持我们看不到的东西，但却在那里 - 在我们需要它们的时候准备好了。有垃圾收集器，对异常处理的支持，当发生未处理的异常时格式化和打印堆栈痕迹到控制台的代码，以及许多其他隐藏在底层的东西。

编译器可以检测到这些都不需要，并避免生成它们，但我们要做的事情非常奇怪，不值得添加编译器功能来支持它。避免这种情况的方法是简单地提供一个替代的运行时库。

让我们从重新定义一个最小版本的基本类型开始：

```bash
namespace System
{
    public class Object
    {
        // 对象的布局是与编译器的契约.
        public IntPtr m_pEEType;
    }
    public struct Void { }

    // 原始类型的布局是特例，因为它将是递归的。
    // 这些真的不需要任何字段来工作。
    public struct Boolean { }
    public struct Char { }
    public struct SByte { }
    public struct Byte { }
    public struct Int16 { }
    public struct UInt16 { }
    public struct Int32 { }
    public struct UInt32 { }
    public struct Int64 { }
    public struct UInt64 { }
    public struct IntPtr { }
    public struct UIntPtr { }
    public struct Single { }
    public struct Double { }

    public abstract class ValueType { }
    public abstract class Enum : ValueType { }

    public struct Nullable<T> where T : struct { }
    
    public sealed class String
    {
        // 字符串类型的布局是与编译器的契约。
        public readonly int Length;
        public char _firstChar;

        public unsafe char this[int index]
        {
            [System.Runtime.CompilerServices.Intrinsic]
            get
            {
                return Internal.Runtime.CompilerServices.Unsafe.Add(ref _firstChar, index);
            }
        }
    }
    public abstract class Array { }
    public abstract class Delegate { }
    public abstract class MulticastDelegate : Delegate { }

    public struct RuntimeTypeHandle { }
    public struct RuntimeMethodHandle { }
    public struct RuntimeFieldHandle { }

    public class Attribute { }
}

namespace System.Runtime.CompilerServices
{
    internal sealed class IntrinsicAttribute : Attribute { }

    public class RuntimeHelpers
    {
        public static unsafe int OffsetToStringData => sizeof(IntPtr) + sizeof(int);
    }
}

namespace System.Runtime.InteropServices
{
    public enum CharSet
    {
        None = 1,
        Ansi = 2,
        Unicode = 3,
        Auto = 4,
    }

    public sealed class DllImportAttribute : Attribute
    {
        public string EntryPoint;
        public CharSet CharSet;
        public DllImportAttribute(string dllName) { }
    }

    public enum LayoutKind
    {
        Sequential = 0,
        Explicit = 2,
        Auto = 3,
    }

    public sealed class StructLayoutAttribute : Attribute
    {
        public StructLayoutAttribute(LayoutKind layoutKind) { }
    }
}
namespace Internal.Runtime.CompilerServices
{
    public static unsafe partial class Unsafe
    {
        // 这个方法的主体是由编译器生成的。
        // 它将做Unsafe.Add应该做的事情。只是不可能用C#来表达它。
        [System.Runtime.CompilerServices.Intrinsic]
        public static extern ref T Add<T>(ref T source, int elementOffset);
    }
}
```

在这一点上，让我们放弃项目文件和dotnet CLI，直接启动各个工具。我们首先启动C#编译器（CSC）。我建议从 "x64 Native Tools Command Prompt for VS 2019 "启动这些命令 - 如果你安装了Visual Studio，它就在你的开始菜单中。正确的工具版本在该窗口的PATH上。

`/noconfig`、`/nostdlib`和`/runtimemetadataversion`是编译定义`System.Object`的东西需要的神奇开关。我选择了`.lexe`文件扩展名而不是`.exe`，因为`.exe`将被用于成品。

```bash
csc.exe /debug /O /noconfig /nostdlib /runtimemetadataversion:v4.0.30319 MiniBCL.cs Game\FrameBuffer.cs Game\Random.cs Game\Game.cs Game\Snake.cs Pal\Thread.Windows.cs Pal\Environment.Windows.cs Pal\Console.Windows.cs /out:zerosnake.ilexe /langversion:latest /unsafe
```

这将成功地用C#编译器编译出游戏的IL字节码版本。我们仍然需要某种运行时来执行它。

让我们尝试将其送入CoreRT提前编译器，从IL中生成本地代码。如果你按照上面的步骤，你会在你的NuGet软件包缓存中找到ilc.exe，即CoreRT提前编译器（类似于`%USERPROFILE%\.nuget\packages\runtime.win-x64.microsoft.dotnet.ilcompiler\1.0.0-alpha-27402-01\Tools`的地方）。

```bash
ilc.exe zerosnake.ilexe -o zerosnake.obj --systemmodule zerosnake --Os -g
```

这将会以 "预期类型'Internal.Runtime.CompilerHelpers.StartupCodeHelpers'未在模块'zerosnake'中找到"的异常而崩溃。事实证明，除了一个托管的开发者所期望的明显的最低限度外，还有一个CoreRT编译器编译输入的最低限度。

让我们跳到后面去，添加需要的东西：

```csharp
namespace Internal.Runtime.CompilerHelpers
{
    // 编译器寻找的一个类，它有帮助器来初始化
    // 进程。编译器可以优雅地处理不存在的帮助器。
    // 但是类本身不存在则无法处理。让我们添加一个空类。
    class StartupCodeHelpers
    {
    }
}

namespace System
{
    // 一种特殊的类型，编译器用它来实现通用接口
    // (例如IEnumerable<T>)的数组。我们的数组将不会实现任何通用接口。
    class Array<T> : Array { }
}

namespace System.Runtime.InteropServices
{
    // 自定义属性，标志着一个类具有特殊的"调用"。
    // 编译器有特殊的逻辑处理类型，有这个属性。
    internal class McgIntrinsicsAttribute : Attribute { }
}

namespace System.Runtime.CompilerServices
{
    // 一个负责运行静态构造函数的类。编译器将调用这个
    //代码以确保静态构造函数的运行，并且只运行一次。
    [System.Runtime.InteropServices.McgIntrinsics]
    internal static class ClassConstructorRunner
    {
        private static unsafe IntPtr CheckStaticClassConstructionReturnNonGCStaticBase(ref StaticClassConstructionContext context, IntPtr nonGcStaticBase)
        {
            CheckStaticClassConstruction(ref context);
            return nonGcStaticBase;
        }

        private static unsafe void CheckStaticClassConstruction(ref StaticClassConstructionContext context)
        {
            // 非常简化的类构造函数运行器。在现实世界中，类构造器运行器
            // 需要能够处理潜在的多个线程竞相初始化的问题。
            // 一个单一的类，并需要能够处理潜在的死锁
            // 类构造函数之间的潜在死锁。

            // 如果该类已经被初始化，我们就完成了。
            if (context.initialized == 1)
                return;

            // 将该类标记为初始化。
            context.initialized = 1;

            // 运行类的构造函数。
            Call<int>(context.cctorMethodAddress);
        }

        // 这是一个特殊的编译器内在因素，调用pfn所指向的方法。
        // 编译器会为此生成代码，我们只需将其标记为 "extern"。
        // 一旦C#得到适当的函数指针支持（计划在C#9中），就不需要这个了。
        [System.Runtime.CompilerServices.Intrinsic]
        private static extern T Call<T>(System.IntPtr pfn);
    }

    // 这个数据结构是与编译器的契约。它持有一个静态
    // 构造函数的地址，以及一个指定该构造函数是否已经执行的标志。
    [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
    public struct StaticClassConstructionContext
    {
        // 指向静态类构造方法代码的指针。这是由
        // 绑定器/运行时。
        public IntPtr cctorMethodAddress;

        // 该类的初始化状态。这被初始化为0
        // 时，运行时都会调用类库的CheckStaticClassConstruction，并使用这个上下文。
        //结构，除非初始化==1。这个检查是特定的，以允许类库为每一个Cctor存储更多的
        // 比二进制状态更多，如果它想这样做的话。
        public int initialized;
    }
}
```

让我们用这些新添加的代码重建IL字节码，并重新运行ILC。

```bash
csc.exe /debug /O /noconfig /nostdlib /runtimemetadataversion:v4.0.30319 MiniRuntime.cs MiniBCL.cs Game\FrameBuffer.cs Game\Random.cs Game\Game.cs Game\Snake.cs Pal\Thread.Windows.cs Pal\Environment.Windows.cs Pal\Console.Windows.cs /out:zerosnake.ilexe /langversion:latest /unsafeilc.exe zerosnake.ilexe -o zerosnake.obj --systemmodule zerosnake --Os -g
```

现在我们有了zerosnake.obj - 一个标准的对象文件，与其他本地编译器（如C或C++）产生的对象文件没有区别。最后一步是连接它。我们将使用link.exe工具，它应该在我们的 "x64本地工具命令提示符 "的PATH中（你可能需要在Visual Studio中安装C/C++开发工具）。

```bash
link.exe /debug:full /subsystem:console zerosnake.obj /entry:__managed__Main
```

`__managed__Main`符号名称是与编译器的契约 - 它是ILC创建的程序的托管入口的名称。

但它并没有发挥作用:

```bash
error LNK2001: unresolved external symbol RhpPInvoke
error LNK2001: unresolved external symbol SetConsoleTextAttribute
error LNK2001: unresolved external symbol WriteConsoleW
error LNK2001: unresolved external symbol GetStdHandle
...
fatal error LNK1120: 17 unresolved externals
```

其中一些符号看起来很熟悉 - 链接器不知道在哪里寻找我们调用的Windows API。让我们来添加这些的导入库:

```bash
link.exe /debug:full /subsystem:console zerosnake.obj /entry:__managed__Main kernel32.lib ucrt.lib
```

这看起来更好 - 只有4个未解决的符号:

```bash
error LNK2001: unresolved external symbol RhpPInvoke
error LNK2001: unresolved external symbol RhpPInvokeReturn
error LNK2001: unresolved external symbol RhpReversePInvoke2
error LNK2001: unresolved external symbol RhpReversePInvokeReturn2
fatal error LNK1120: 4 unresolved externals
```

其余缺失的符号是编译器希望在运行时库中找到的辅助工具。它们的缺失只有在链接时才会被发现，因为这些辅助工具通常是在汇编中实现的，而且编译器只用它们的符号名称来指代它们（而不是我们上面提供的其他编译器需要的类型和方法）。

当本机代码调用到托管代码，以及托管代码调用到本机代码时，这些帮助程序会建立和拆除堆栈框架。这对于GC的运行是必要的。由于我们没有GC，让我们用一段C#和另一个编译器能理解的神奇属性来存根它们。

```csharp
namespace System.Runtime
{
    // 编译器理解的自定义属性，指示它
    // 在给定的符号名称下导出方法。
    internal sealed class RuntimeExportAttribute : Attribute
    {
        public RuntimeExportAttribute(string entry) { }
    }
}

namespace Internal.Runtime.CompilerHelpers
{
    class StartupCodeHelpers
    {
        // 这些方法的包含类型并不重要。
        // 让我们把它们放在StarupCodeHelpers中。
        
        [System.Runtime.RuntimeExport("RhpReversePInvoke2")]
        static void RhpReversePInvoke2(System.IntPtr frame) { }
        [System.Runtime.RuntimeExport("RhpReversePInvokeReturn2")]
        static void RhpReversePInvokeReturn2(System.IntPtr frame) { }
        [System.Runtime.RuntimeExport("RhpPInvoke")]
        static void RhpPinvoke(System.IntPtr frame) { }
        [System.Runtime.RuntimeExport("RhpPInvokeReturn")]
        static void RhpPinvokeReturn(System.IntPtr frame) { }
    }
}
```

在用这些修改重建C#源代码并重新运行ILC后，链接终于会成功。

我们现在已经只有27KB，而且游戏还能正常运行!

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/6806148a-5498-42a7-9680-177e7f6fb139.jpg)

# 扰乱链接器

剩余的几千字节可以通过使用本地开发者用来缩小其本地应用程序的技巧来削减。

我们要做的是

- 禁用增量链接
- 剥离重定位信息
- 合并可执行文件中的类似部分
- 将可执行文件中的内部对齐设置为一个小值

```bash
link.exe /debug:full /subsystem:console zerosnake.obj /entry:__managed__Main kernel32.lib ucrt.lib /merge:.modules=.rdata /merge:.pdata=.rdata /incremental:no /DYNAMICBASE:NO /filealign:16 /align:16
```

成功! 最后只有8176字节，不到8KB !

游戏仍然可以运行，有趣的是，它仍然是完全可调试的 - 请在Visual Studio中打开EXE（文件->打开解决方案），打开作为游戏一部分的一个C#文件，在其中设置一个断点，点击F5启动EXE，并看到断点被击中。你可以在ILC中禁用优化，使可执行文件更容易被调试 - 只要放弃`--Os`参数。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/b3ae3234-df47-4f49-88ef-785433f21620.jpg)

# 我们可以把它编译得更小吗？

可执行文件仍然携带着一些并非必要的数据 - ILC编译器只是没有提供命令行选项来禁止其生成。

其中一个被生成但我们不需要的数据结构是各个方法的GC信息。CoreRT有一个精确的垃圾收集器，它要求每个方法描述GC堆的引用在方法主体的每个指令中的位置。由于我们在Snake游戏中没有垃圾收集器，这些数据是不必要的。其他运行时（例如Mono）使用保守的垃圾收集器，不需要这些数据（它只是假设堆栈和CPU寄存器的任何部分都可能是GC引用）- 保守的垃圾收集器以GC性能换取额外的大小节省。CoreRT中使用的精确的垃圾收集器也可以在保守模式下运行，但它还没有被连接起来。这是一个潜在的未来补充，我们可以利用它来使程序编译得更小。

也许有一天，我们可以使我们的游戏的简化版本适合于512字节的启动扇区。在那之前，祝你黑客行动愉快.

anonymous 2023/02/09 14:02

anonymous 2023/07/07 11:07