有没有人比较用Xamarin C＃和Java编写的Android应用程序的性能基准（代码和结果）？ [关闭]

这篇博客介绍了作者对比Xamarin C#和Java编写的Android应用程序性能的测试结果。在不同设备和模拟器上进行的测试显示，在ARM处理器的设备上，Java通常表现优于Xamarin C#，而在使用Intel处理器的模拟器上，Xamarin C#更快。测试涉及文本解析、替换和正则表达式搜索。最新测试结果显示，经过更新后的Dot42在某些情况下性能有所提升，但仍落后于Xamarin和Java。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文翻译自：Does anyone have benchmarks (code & results) comparing performance of Android apps written in Xamarin C# and Java? [closed]

I came across Xamarin claims that their Mono implementation on Android and their C# compiled apps are faster than Java code. 我遇到Xamarin声称他们在Android上的Mono实现和他们的C＃编译应用程序比Java代码更快。 Did anyone perform actual benchmarks on very similar Java and C# code on different Android platforms to verify such claims, could post the code and results? 有没有人在不同的Android平台上对非常相似的Java和C＃代码执行实际基准来验证此类声明，是否可以发布代码和结果？

Added June 18, 2013 2013年6月18日新增

Since there was no answer and could not find such benchmarks done by others, decided to do my own tests. 由于没有答案，也找不到其他人做的基准，所以决定自己做测试。 Unfortunately, my question remains "locked" so I cannot post this as the answer, only edit the question. 不幸的是，我的问题仍然是“锁定”，所以我不能将其作为答案发布，只编辑问题。 Please vote to re-open this question. 请投票重新打开这个问题。 For C#, I used Xamarin.Android Ver. 对于C＃，我使用了Xamarin.Android Ver。 4.7.09001 (beta). 4.7.09001（测试版）。 The source code, all the data I used for testing and compiled APK packages are on GitHub: 源代码，我用于测试和编译的APK包的所有数据都在GitHub上：

Java: https://github.com/gregko/TtsSetup_Java Java： https ： //github.com/gregko/TtsSetup_Java

C#: https://github.com/gregko/TtsSetup_C_sharp C＃： https ： //github.com/gregko/TtsSetup_C_sharp

If someone would like to repeat my tests on other devices or emulators, I'd be interested to learn the results as well. 如果有人想在其他设备或模拟器上重复我的测试，我也有兴趣了解结果。

Results from my testing 我的测试结果

I ported my sentence extractor class to C# (from my @Voice Aloud Reader app) and run some tests on 10 HTML files in English, Russian, French, Polish and Czech languages. 我将我的句子提取器类移植到C＃（来自我的@Voice Aloud Reader应用程序），并对英语，俄语，法语，波兰语和捷克语的10个HTML文件进行了一些测试。 Each run was performed 5 times on all 10 files, and the total time for 3 different devices and one emulator are posted below. 所有10个文件的每次运行都执行了5次，下面发布了3个不同设备和一个模拟器的总时间。 I tested "Release" builds only, without debugging enabled. 我只测试了“Release”版本，没有启用调试。

HTC Nexus One Android 2.3.7 (API 10) - CyanogenMod ROM HTC Nexus One Android 2.3.7（API 10） - CyanogenMod ROM

Java: Grand total time (5 runs): 12361 ms, with file reading total: 13304 ms Java：总计时间（5次运行）：12361 ms，文件读取总计：13304 ms

C#: Grand total time (5 runs): 17504 ms, with file reading total: 17956 ms C＃：总计时间（5次运行）：17504 ms，文件读取总计：17956 ms

Samsung Galaxy S2 SGH-I777 (Android 4.0.4, API 15) - CyanogenMod ROM 三星Galaxy S2 SGH-I777（Android 4.0.4，API 15） - CyanogenMod ROM

Java: Grand total time (5 runs): 8947 ms, with file reading total: 9186 ms Java：总计时间（5次运行）：8947 ms，文件读取总计：9186 ms

C#: Grand total time (5 runs): 9884 ms, with file reading total: 10247 ms C＃：总计时间（5次运行）：9884 ms，文件读取总计：10247 ms

Samsung GT-N7100 (Android 4.1.1 JellyBean, API 16) - Samsung ROM 三星GT-N7100（Android 4.1.1 JellyBean，API 16） - 三星ROM

Java: Grand total time (5 runs): 9742 ms, with file reading total: 10111 ms Java：总计时间（5次运行）：9742 ms，文件读取总计：10111 ms

C#: Grand total time (5 runs): 10459 ms, with file reading total: 10696 ms C＃：总计时间（5次运行）：10459 ms，文件读取总计：10696 ms

Emulator - Intel (Android 4.2, API 17) 仿真器 - 英特尔（Android 4.2，API 17）

Java: Grand total time (5 runs): 2699 ms, with file reading total: 3127 ms Java：总时间（5次运行）：2699 ms，文件读取总数：3127 ms

C#: Grand total time (5 runs): 2049 ms, with file reading total: 2182 ms C＃：总计时间（5次运行）：2049 ms，文件读数总计：2182 ms

Emulator - Intel (Android 2.3.7, API 10) 仿真器 - 英特尔（Android 2.3.7，API 10）

Java: Grand total time (5 runs): 2992 ms, with file reading total: 3591 ms Java：总计时间（5次运行）：2992 ms，文件读取总计：3591 ms

C#: Grand total time (5 runs): 2049 ms, with file reading total: 2257 ms C＃：总计时间（5次运行）：2049 ms，文件读取总数：2257 ms

Emulator - Arm (Android 4.0.4, API 15) 模拟器 - 手臂（Android 4.0.4，API 15）

Java: Grand total time (5 runs): 41751 ms, with file reading total: 43866 ms Java：总计时间（5次运行）：41751 ms，文件读取总计：43866 ms

C#: Grand total time (5 runs): 44136 ms, with file reading total: 45109 ms C＃：总计时间（5次运行）：44136 ms，文件读取总计：45109 ms

Brief discussion 简要讨论

My test code contains mainly text parsing, replacing and Regex searches, perhaps for other code (eg more numeric operations) the results would be different. 我的测试代码主要包含文本解析，替换和正则表达式搜索，可能用于其他代码（例如更多的数字操作），结果会有所不同。 On all devices with ARM processors, Java performed better than Xamarin C# code. 在所有使用ARM处理器的设备上，Java的性能优于Xamarin C＃代码。 The largest difference was under Android 2.3, where C# code run at approx. 最大的区别在于Android 2.3，其中C＃代码大约运行。 70% of Java speed. 70％的Java速度。

On Intel emulator (with Intel HAX technology, emulator runs in fast virt mode), Xamarin C# code runs my sample code much faster than Java - about 1.35 time faster. 在英特尔模拟器上（使用英特尔HAX技术，模拟器以快速模式运行），Xamarin C＃代码比Java快得多地运行我的示例代码 - 大约快了1.35倍。 Maybe Mono virtual machine code and libraries are much better optimized on Intel than on ARM? 也许Mono虚拟机代码和库在英特尔上比在ARM上更优化？

Edit July 8, 2013 编辑2013年7月8日

I just installed Genymotion Android emulator, which runs in Oracle VirtualBox, and again this one uses native Intel processor, not emulating ARM processor. 我刚刚安装了在Oracle VirtualBox中运行的Genymotion Android模拟器，而且这个模拟器再次使用原生英特尔处理器，而不是模拟ARM处理器。 As with Intel HAX emulator, again C# runs here much faster. 与英特尔HAX仿真器一样，C＃再次在这里运行得更快。 Here are my results: 这是我的结果：

Genymotion emulator - Intel (Android 4.1.1, API 16) Genymotion模拟器 - 英特尔（Android 4.1.1，API 16）

Java: Grand total time (5 runs): 2069 ms, with file reading total: 2248 ms Java：总计时间（5次运行）：2069 ms，文件读取总计：2248 ms

C#: Grand total time (5 runs): 1543 ms, with file reading total: 1642 ms C＃：总计时间（5次运行）：1543 ms，文件读取总计：1642 ms

I then noticed that there was an update to Xamarin.Android beta, version 4.7.11, with release notes mentioning some changes in Mono runtime as well. 然后我注意到Xamarin.Android beta版本4.7.11有更新，发行说明也提到了Mono运行时的一些变化。 Decided to quickly test some ARM devices, and big surprise - C# numbers improved: 决定快速测试一些ARM设备，并且大惊喜--C＃数字得到改善：

BN Nook XD+, ARM (Android 4.0) BN Nook XD +，ARM（Android 4.0）

Java: Grand total time (5 runs): 8103 ms, with file reading total: 8569 ms Java：总计时间（5次运行）：8103 ms，文件读取总计：8569 ms

C#: Grand total time (5 runs): 7951 ms, with file reading total: 8161 ms C＃：总计时间（5次运行）：7951 ms，文件读取总计：8161 ms

Wow! 哇！ C# is now better than Java? C＃现在比Java好吗？ Decided to repeat the test on my Galaxy Note 2: 决定在我的Galaxy Note 2上重复测试：

Samsung Galaxy Note 2 - ARM (Android 4.1.1) 三星Galaxy Note 2 - ARM（Android 4.1.1）

Java: Grand total time (5 runs): 9675 ms, with file reading total: 10028 ms Java：总计时间（5次运行）：9675 ms，文件读取总计：10028 ms

C#: Grand total time (5 runs): 9911 ms, with file reading total: 10104 ms C＃：总计时间（5次运行）：9911 ms，文件读取总计：10104 ms

Here C# seems to be only slightly slower, but these numbers gave me a pause: Why the time is longer than on Nook HD+, even though Note 2 has a faster processor? 这里的C＃似乎只是稍微慢一点，但是这些数字给了我一个停顿：为什么时间比Nook HD +更长，即使Note 2有更快的处理器？ The answer: power saving mode. 答案：省电模式。 On Nook, it was disabled, on Note 2 - enabled. 在Nook上，它已被禁用，在注2 - 已启用。 Decided to test with power saving mode disabled (as with enabled, it also limits the processor speed): 决定禁用省电模式进行测试（与启用时一样，它也会限制处理器速度）：

Samsung Galaxy Note 2 - ARM (Android 4.1.1), power saving disabled 三星Galaxy Note 2 - ARM（Android 4.1.1），省电禁用

Java: Grand total time (5 runs): 7153 ms, with file reading total: 7459 ms Java：总计时间（5次运行）：7153 ms，文件读取总计：7459 ms

C#: Grand total time (5 runs): 6906 ms, with file reading total: 7070 ms C＃：总计时间（5次运行）：6906 ms，文件读取总计：7070 ms

Now, surprisingly, C# is slightly faster than Java on ARM processor as well. 现在，令人惊讶的是，C＃在ARM处理器上的速度也略快于Java。 Big improvement! 大改进！

Edit July 12, 2013 编辑2013年7月12日

We all know, that nothing beats native code for speed, and I was not satisfied with the performance of my sentence splitter in Java or C#, particularly that I need to improve it (and thus make it even slower). 我们都知道，没有什么比速度本机代码更好，我对Java或C＃中的句子分割器的性能不满意，特别是我需要改进它（因此使它更慢）。 Decided to re-write it in C++. 决定用C ++重写它。 Here is a small (ie a smaller set of files than previous tests, for other reasons) comparison of the speed of native vs. Java on my Galaxy Note 2, with power saving mode disabled: 这是一个小的（即比以前的测试更小的文件集，出于其他原因）比较我的Galaxy Note 2上原生与Java的速度，禁用了省电模式：

Java: Grand total time (5 runs): 3292 ms, with file reading total: 3454 ms Java：总计时间（5次运行）：3292 ms，文件读取总计：3454 ms

Native thumb: Grand total time (5 runs): 537 ms, with file reading total: 657 ms Native thumb：总计总时间（5次运行）：537 ms，文件读取总计：657 ms

Native arm: Grand total time (5 runs): 458 ms, with file reading total: 587 ms 本机臂：总计时间（5次运行）：458 ms，文件读数总计：587 ms

Looks like for my particular test, the native code is 6 to 7 times faster than Java. 看起来对于我的特定测试，本机代码比Java快6到7倍。 Caveat: could not use std::regex class on Android, so had to write my own specialized routines searching for paragraphs breaks or html tags. 警告：无法在Android上使用std :: regex类，因此必须编写我自己的专用例程来搜索段落符号或html标记。 My initial tests of the same code on a PC using regex, were about 4 to 5 times faster than Java. 我在使用正则表达式的PC上对相同代码的初始测试比Java快4到5倍。

Phew! 唷！ Waking raw memory with char* or wchar* pointers again, I instantly felt 20 years younger! 再次使用char *或wchar *指针唤醒原始内存，我立即觉得年轻20岁！ :) :)

Edit July 15, 2013 编辑2013年7月15日

(Please see below, with edits of 7/30/2013, for much better results with Dot42) （请参见下文，编辑时间为2013年7月30日，以获得更好的Dot42结果）

With some difficulty, I managed to port my C# tests to Dot42 (version 1.0.1.71 beta), another C# platform for Android. 有一些困难，我设法将我的C＃测试移植到Dot42（版本1.0.1.71 beta），这是Android的另一个C＃平台。 Preliminary results show that Dot42 code is about 3x (3 times) slower than Xamarin C# (v. 4.7.11), on an Intel Android emulator. 初步结果显示，在Intel Android仿真器上，Dot42代码比Xamarin C＃（v.4.7.11）慢约3倍（3倍）。 One problem is that System.Text.RegularExpressions class in Dot42 does not have the Split() function that I used in Xamarin tests, so I used Java.Util.Regex class instead, and Java.Util.Regex.Pattern.Split(), so in this particular place in the code, there is this small difference. 一个问题是Dot42中的System.Text.RegularExpressions类没有我在Xamarin测试中使用的Split（）函数，所以我使用了Java.Util.Regex类，而Java.Util.Regex.Pattern.Split（），所以在代码中的这个特定位置，存在这种小差异。 Should not be a big problem though. 不过应该不是一个大问题。 Dot42 compiles to Dalvik (DEX) code, so it cooperates with Java on Android natively, does not need expensive interop from C# to Java like Xamarin. Dot42编译成Dalvik（DEX）代码，因此它本身就与Android上的Java合作，不需要像Xamarin那样从C＃到Java的昂贵的互操作。

Just for comparison, I also run the test on ARM devices - here the Dot42 code is "only" 2x slower than Xamarin C#. 仅仅为了比较，我还在ARM设备上运行测试 - 这里的Dot42代码“仅”比Xamarin C＃慢2倍。 Here are my results: 这是我的结果：

HTC Nexus One Android 2.3.7 (ARM) HTC Nexus One Android 2.3.7（ARM）

Java: Grand total time (5 runs): 12187 ms, with file reading total: 13200 ms Java：总计时间（5次运行）：12187 ms，文件读取总计：13200 ms

Xamarin C#: Grand total time (5 runs): 13935 ms, with file reading total: 14465 ms Xamarin C＃：总计时间（5次运行）：13935 ms，文件读取总数：14465 ms

Dot42 C#: Grand total time (5 runs): 26000 ms, with file reading total: 27168 ms Dot42 C＃：总计时间（5次运行）：26000 ms，文件读取总计：27168 ms

Samsung Galaxy Note 2, Android 4.1.1 (ARM) 三星Galaxy Note 2，Android 4.1.1（ARM）

Java: Grand total time (5 runs): 6895 ms, with file reading total: 7275 ms Java：总计时间（5次运行）：6895 ms，文件读取总数：7275 ms

Xamarin C#: Grand total time (5 runs): 6466 ms, with file reading total: 6720 ms Xamarin C＃：总计时间（5次运行）：6466 ms，文件读取总数：6720 ms

Dot42 C#: Grand total time (5 runs): 11185 ms, with file reading total: 11843 ms Dot42 C＃：总计时间（5次运行）：11185 ms，文件读取总数：11843 ms

Intel emulator, Android 4.2 (x86) 英特尔模拟器，Android 4.2（x86）

Java: Grand total time (5 runs): 2389 ms, with file reading total: 2770 ms Java：总计时间（5次运行）：2389 ms，文件读取总计：2770 ms

Xamarin C#: Grand total time (5 runs): 1748 ms, with file reading total: 1933 ms Xamarin C＃：总计时间（5次运行）：1748 ms，文件读取总数：1933 ms

Dot42 C#: Grand total time (5 runs): 5150 ms, with file reading total: 5459 ms Dot42 C＃：总计时间（5次运行）：5150 ms，文件读取总数：5459 ms

To me, it was also interesting to note that Xamarin C# is slightly faster than Java on a newer ARM device and slightly slower on the old Nexus One. 对我来说，值得注意的是，Xamarin C＃在较新的ARM设备上略快于Java，在旧的Nexus One上略慢。 If anyone would like to run these tests as well, please let me know and I'll update the sources on GitHub. 如果有人想要运行这些测试，请告诉我，我将在GitHub上更新源代码。 It would be particularly interesting to see results from a real Android device with Intel processor. 从具有英特尔处理器的真实Android设备看到结果会特别有趣。

Update 7/26/2013 2013年7月26日更新

Just a quick update, re-compiled by benchmark apps with the latest Xamarin.Android 4.8, and also with dot42 1.0.1.72 update released today - no significant changes from the results reported before. 只是一个快速更新，由基准应用程序使用最新的Xamarin.Android 4.8重新编译，以及今天发布的dot42 1.0.1.72更新 - 之前报告的结果没有重大变化。

Update 7/30/2013 - better results for dot42 2013年7月30日更新 - dot42的更好结果

Re-tested Dot42 with Robert's (from dot42 makers) port of my Java code to C#. 使用我的Java代码的Robert（来自dot42制造商）端口重新测试Dot42到C＃。 In my C# port done initially for Xamarin, I replaced some native Java classes, like ListArray, with List class native to C#, etc. Robert did not have my Dot42 source code, so he ported it again from Java and used original Java classes in such places, which benefits Dot42, I guess because it runs in Dalvik VM, like Java, and not in Mono, like Xamarin. 在我最初为Xamarin完成的C＃端口中，我替换了一些本地Java类，如ListArray，使用C＃原生的List类，等等.Robert没有我的Dot42源代码，因此他再次从Java移植它并使用原始Java类这样的地方，有利于Dot42，我猜是因为它在Dalvik VM中运行，就像Java一样，而不是在Mono中运行，就像Xamarin一样。 Now Dot42 results are much better. 现在Dot42的结果要好得多。 Here is a log from my testing: 这是我测试的日志：

7/30/2013 - Dot42 tests with more Java classes in Dot42 C# 2013年7月30日 - Dot42在Dot42 C中测试更多Java类＃

Intel emulator, Android 4.2 英特尔模拟器，Android 4.2

Dot42, Greg's Code using StringBuilder.Replace() (as in Xamarin): Dot42，Greg的代码使用StringBuilder.Replace（）（如在Xamarin中）：
Grand total time (5 runs): 3646 ms, with file reading total: 3830 ms 总计时间（5次运行）：3646 ms，文件读取总计：3830 ms

Dot42, Greg's Code using String.Replace() (as in Java and Robert's code): Dot42，Greg的代码使用String.Replace（）（如在Java和Robert的代码中）：
Grand total time (5 runs): 3027 ms, with file reading total: 3206 ms 总计时间（5次运行）：3027 ms，文件读数总计：3206 ms

Dot42, Robert's Code: Dot42，Robert的代码：
Grand total time (5 runs): 1781 ms, with file reading total: 1999 ms 总计时间（5次运行）：1781 ms，文件读取总数：1999 ms

Xamarin: Xamarin：
Grand total time (5 runs): 1373 ms, with file reading total: 1505 ms 总计时间（5次运行）：1373 ms，文件读取总计：1505 ms

Java: Java的：
Grand total time (5 runs): 1841 ms, with file reading total: 2044 ms 总计时间（5次运行）：1841 ms，文件读取总计：2044 ms

ARM, Samsung Galaxy Note 2, power saving off, Android 4.1.1 ARM，三星Galaxy Note 2，省电，Android 4.1.1

Dot42, Greg's Code using StringBuilder.Replace() (as in Xamarin): Dot42，Greg的代码使用StringBuilder.Replace（）（如在Xamarin中）：
Grand total time (5 runs): 10875 ms, with file reading total: 11280 ms 总计时间（5次运行）：10875 ms，文件读取总计：11280 ms

Dot42, Greg's Code using String.Replace() (as in Java and Robert's code): Dot42，Greg的代码使用String.Replace（）（如在Java和Robert的代码中）：
Grand total time (5 runs): 9710 ms, with file reading total: 10097 ms 总计时间（5次运行）：9710 ms，文件读取总计：10097 ms

Dot42, Robert's Code: Dot42，Robert的代码：
Grand total time (5 runs): 6279 ms, with file reading total: 6622 ms 总计时间（5次运行）：6279 ms，文件读取总计：6622 ms

Xamarin: Xamarin：
Grand total time (5 runs): 6201 ms, with file reading total: 6476 ms 总计时间（5次运行）：6201 ms，文件读取总计：6476 ms

Java: Java的：
Grand total time (5 runs): 7141 ms, with file reading total: 7479 ms 总计时间（5次运行）：7141 ms，文件读取总计：7479 ms

I still think that Dot42 has a long way to go. 我仍然认为Dot42还有很长的路要走。 Having Java-like classes (eg ArrayList) and a good performance with them would make porting code from Java to C# slightly easier. 拥有类似Java的类（例如ArrayList）以及它们的良好性能将使得从Java到C＃的代码移植稍微容易一些。 However, this is something I would not be likely to do a lot. 但是，这是我不太可能做的事情。 I would rather want to use existing C# code (libraries etc.), which will use native C# classes (eg List), and that would perform slowly with the current dot42 code, and very well with Xamarin. 我宁愿使用现有的C＃代码（库等），它们将使用本机C＃类（例如List），并且使用当前的dot42代码执行缓慢，并且与Xamarin非常相似。

Greg 格雷格

#1楼

参考：https://stackoom.com/question/19tTG/有没有人比较用Xamarin-C-和Java编写的Android应用程序的性能基准-代码和结果-关闭

#2楼

Yeah, Xamarin's Mono virtual machine is more impressive than Google's Dalvik used in Android. 是的，Xamarin的Mono虚拟机比谷歌在Android中使用的Dalvik更令人印象深刻。 I have tested it with HTC Flyer and Acer Iconia Tab tablets to benchmark the C# port of Android through Mono against Java Dalvik, with the C# implementation of Android well and truly trouncing the Java-based Dalvik. 我用HTC Flyer和Acer Iconia Tab平板电脑对它进行了测试，通过Mono对抗Java Dalvik，对Android的C＃端口进行了基准测试，使用Android的C＃实现，真正打败了基于Java的Dalvik。

#3楼

We recently investigated using Xamarin for an app. 我们最近调查使用Xamarin作为应用程序。 We utilized the C# code we had already written for the Windows RT version of our app. 我们使用了我们已经为我们的应用程序的Windows RT版本编写的C＃代码。 Some specific details had to be rewritten for the Android version. 必须为Android版本重写一些具体细节。

What we discovered is that I/O in Xamarin C# is approximately 2x slower than Java. 我们发现Xamarin C＃中的I / O比Java慢大约2倍。 Our app is heavily I/O bound. 我们的应用程序严重受I / O限制。 We have not discovered the cause of this yet, but at the moment we are assuming that it is due to marshaling. 我们还没有找到原因，但目前我们假设这是由于编组。 While we do try to stay inside the Mono VM most of the time, we do not know how Mono actually accesses the disk. 虽然我们大多数时间都试图留在Mono VM中，但我们不知道Mono如何实际访问磁盘。

It is also telling that our C# code uses SQLite.NET ( https://github.com/praeclarum/sqlite-net ). 它还告诉我们的C＃代码使用SQLite.NET（ https://github.com/praeclarum/sqlite-net ）。 Identical fetches using the SQLite.NET code are also 2x slower than using Android's Java SQLite wrapper. 使用SQLite.NET代码的相同提取也比使用Android的Java SQLite包装器慢2倍。 After looking at the source code, it appears to bind directly to the C .dll, so I do not know why it's so much slower. 看完源代码后，它似乎直接绑定到C .dll，所以我不知道它为什么这么慢。 One possibility is that marshaling strings from native to Java may be faster on Android than native to C# is on Xamarin. 一种可能性是，从原生到Java的编组可能在Android上比在Xamarin上使用C＃本机更快。

#4楼

This is another more updated blog post I would like to share with you . 这是我想与您分享的另一篇更新的博客文章。 He compares Xamarin to native code and Cordova on both IOs and Android. 他将Xamarin与IO和Android上的本机代码和Cordova进行了比较。

In a nutshell, Xamarin performs sometimes better than native code. 简而言之，Xamarin有时比本机代码更好。 He tested the app size, load times, loading a list from Azure service and prime number computation. 他测试了应用程序大小，加载时间，从Azure服务加载列表和素数计算。

Enjoy! 请享用！

Edit: I updated the dead link and I noticed that there is a part 2 编辑：我更新了死链接，我注意到有第2部分