重新认识C#: 玩转指针
许多文章并不鼓励在C#下使用指针开发，不过，本文偏偏要这样做。在大量尝试C#下使用指针开发之后，你会对C#有更深的认识。
在说C#下的指针之前，需要提一下C++/CLI。C++/CLI 我们可以把它看作两部分：Native C++和 Managed C++，两者可以无缝结合。对C#，我们也可以把它看作两部分：Managed C# 和 Unmanaged C#。Managed C# 和 Unmanaged C# 是我杜撰的两个词，前者就是我们通常的C#，后者就是使用指针、Struct和非托管内存的C#。事实证明，Unmanaged C#也可以玩的十分优雅——它具有C语言的大部分特性，却比C语言好用的多。 C# 与 C++/CLI之间的对应关系见下图：
C++/CLI默认是 Native C++，而C# 默认是 Managed C# 。除了不能内嵌汇编以及编译方式不同之外，C++/CLI和C#两者在层面上几乎是等价的。其中，C++/CLI略微偏底层一点，C#略微偏高层一点。尽管略微偏高层一点，C#仍然可以当成准系统语言来玩。你可以将Unmanaged C# 当作 mini c 来玩，区别只是，C 语言一般是编译执行的，而 Unmanaged C# 是先编译成 IL ，再使用Ngen编译成机器码或在运行时编译成机器码执行。
在C#下不鼓励使用指针，这是因为C#的定位是应用级的开发，如果我们把它定位为低一级别的开发，那么，就需要大量的使用指针了。大量使用指针进行Unmanaged C#开发，“本质”上就是使用 C 语言。只是因为目前 JIT 技术发展年代仍不够久远，导致 Unmamaged C# 的性能较 C 语言 略低。
下面，画张图，描述一下当下的C#语言。
当下的C#包含了五种编程范式：类C、OO、泛型、Lambda、Dynamic。关于 OO、泛型、Lambda、Dynamic已经有很多文章介绍和总结了，关于类C这一块却很少有人写文章详细介绍。就像Ajax重新发现了javascript一样，我们也应该去重新发现C#中的Unmanaged 成分。
回看程序设计语言的发展史。C语言是一直的王者。但是由于抽象能力不足，在C的基础上出现了C++，后来又出现了帮你管家的保姆Java，于是，在系统层开发使用C/C++，在应用层开发使用Java成为一种常见的分工方式。有没有一种语言同时具备Java的快速开发优势和C/C++的高性能且能直接访问内存这两个优点呢？D语言就是奔着这个目标设计的。许多人对D语言报以厚望。可问题是，D语言看起来很美，但太草根了，各方面都不成熟。C#诞生之后，人们认为它和Java的定位是类似的，我也一直这样认为。同时，我还在寻找能够快速开发、自己管理内存、拥有庞大的类库的另一种语言，来进行高性能开发及实时开发。我看过D语言，看过Haskell语言，都不是我想要的，转一圈回来，发现，原来答案已在自己的手中，那就是已经用了很多年的C#——C#的Unmanaged部分。
开发过一个软实时系统，每秒钟有数百万对象生灭，是使用C++开发的。C++开发效率低下，我想寻找一个替代品。最先找到的是Java，由于GC的存在，在Java下开发软实时系统比较困难，以至于出现了专门的Java实时规范和实时Java虚拟机。当时接触C#不久，想，为什么C#下没人研究实时系统？现在知道了答案：那就是开发实时性应用，相对于Java，C#具有非常大的优势——由于Unmanaged 部分的存在，不需要专门的C#实时虚拟机。C# 中，GC 是无法直接插手非托管内存的，如果只有寥寥无几的对象在托管内存中，每一次GC时间十分短暂，可以忽略不计。
这两年开始进行图像处理方面的程序开发。图像处理开发，C/C++是王道。不过，C/C++开发效率低下是个大问题，同样需要寻找替代品。最开始我使用的是C++/CLI，使用后发现，C++/CLI 不好用，它继承了C++的所有缺点，最不能忍受的是狂慢的编译速度。C++/CLI的CLI部分虽然可以使用.Net的庞大的类库，但是没有C#自然。有没有一种更好的方式平衡开发效率和运行效率？有！那就是打开unsafe之后的C#：优雅的语法、快速的编译、庞大的类库、完美的IDE、想托管内存就托管内存，不想托管就不托管——犀利！非常的犀利！无比的犀利！。
在《编写高效的C#图像处理程序——我的实验》和《编写高效的C#图像处理程序——我的实验（续）》两篇文章中，我使用指针，得到了近似C语言的性能。因此，不必担心C#的性能。
C#目前包括的五种编程范式：类C、OO、泛型、Lambda、Dynamic，这五种编程范式几乎可以无缝的结合，熟练使用这些编程范式，可以把C#下的指针玩的天花乱坠：
（1）Class和Struct中可以直接包含指针成员，这样，我们可以设计一套自己的继承体系（当然，得在托管内存中。不过，可以将性能攸关部分放在非托管内存中，然后，将它的指针放到Class中，遵循Disposable模式来管理，避免内存泄漏。）
（2）C#下的泛型不支持泛型Class的指针，于是，我在《C#模板编程(1):有了泛型，为什么还需要模板？》和《C#模板编程(2): 编写C#预处理器，让模板来的再自然一点》这两篇文章中编写了C#的预处理器，再结合using关键字和partial关键字实现了对C++模板的模拟，用以Unmanaged C#代码的强类型复用。
这样处理，就写出了几个纯C#开发的高性能C#图像处理基本类，见博文《发布我的高性能纯C#图像处理基本类，顺便也挑战一下极限。:)》。
这些基本类可以通过指针访问图像的像素，也可以通过索引器来访问像素，也可以通过迭代器来访问像素。通过指针访问速度最快，但比较麻烦。通过索引器和迭代器访问比较慢，但比较方便。不过，通过索引器和迭代器来访问像素很容易误用，比如说，假设图像是A。A[1,2]可以获得图像的第1行(首行为第0行)，第2列（首列为第0列）的像素。假设想更改这个像素的Red值为5，这样写是无效的：A[1,2].Red = 5。因为，A[1,2]是一个Struct实例，它是坐标为（1,2）的像素值的“快照”，对A[1,2]的修改无法写入到图像像素中去，需要这样写才能实现真正的修改：Rgb24 item = A[1,2];item.Red = 5; A[1,2]=item。同理，通过迭代器访问，也无法修改像素具体值。
这样处理既不优雅，又容易误用。怎么办呢？思来想去，我决定取消它！改用另一种方式提供对图像像素的便捷访问。什么办法呢？Lambda表达式！可是，问题来了，C#下的泛型不支持具体的指针类型作为泛型类型，好在关上了一扇门，C#又打开了另一扇门——delegate 支持指针类型！于是，使用《C#模板编程(1):有了泛型，为什么还需要模板？》和《C#模板编程(2): 编写C#预处理器，让模板来的再自然一点》这两篇文章中提出的C#模板开发技巧，编写代码，有：
ImageClassHelper_Template.cs
2 using TCache = System.Int32;
3 using TKernel = System.Int32;
4
5 using System;
6 using System.Collections.Generic;
7 using System.Text;
8
9 namespace Orc.SmartImage.Hidden
10 {
11 static class ImageClassHelper_Template
12 {
13 #region mixin
14
15 public unsafe delegate void ActionOnPixel(TPixel* p);
16 public unsafe delegate Boolean PredicateOnPixel(TPixel* p);
17
18 public unsafe static void ForEach(this UnmanagedImage<TPixel> src, ActionOnPixel handler)
19 {
20 TPixel* start = (TPixel*)src.StartIntPtr;
21 TPixel* end = start + src.Length;
22 while (start != end)
23 {
24 handler(start);
25 ++start;
26 }
27 }
28
29 public unsafe static Int32 Count(this UnmanagedImage<TPixel> src, PredicateOnPixel handler)
30 {
31 TPixel* start = (TPixel*)src.StartIntPtr;
32 TPixel* end = start + src.Length;
33 Int32 count = 0;
34 while (start != end)
35 {
36 if (handler(start) == true) count++;
37 ++start;
38 }
39 return count;
40 }
41
42 public unsafe static Int32 Count(this UnmanagedImage<TPixel> src, Predicate<TPixel> handler)
43 {
44 TPixel* start = (TPixel*)src.StartIntPtr;
45 TPixel* end = start + src.Length;
46 Int32 count = 0;
47 while (start != end)
48 {
49 if (handler(*start) == true) count++;
50 ++start;
51 }
52 return count;
53 }
54
55 public unsafe static List<TPixel> Where(this UnmanagedImage<TPixel> src, PredicateOnPixel handler)
56 {
57 List<TPixel> list = new List<TPixel>();
58
59 TPixel* start = (TPixel*)src.StartIntPtr;
60 TPixel* end = start + src.Length;
61 while (start != end)
62 {
63 if (handler(start) == true) list.Add(*start);
64 ++start;
65 }
66
67 return list;
68 }
69
70 public unsafe static List<TPixel> Where(this UnmanagedImage<TPixel> src, Predicate<TPixel> handler)
71 {
72 List<TPixel> list = new List<TPixel>();
73
74 TPixel* start = (TPixel*)src.StartIntPtr;
75 TPixel* end = start + src.Length;
76 while (start != end)
77 {
78 if (handler(*start) == true) list.Add(*start);
79 ++start;
80 }
81
82 return list;
83 }
84
85 #endregion
86 }
87 }
这样一来，就提供了ForEach扩展方法，可以通过指针直接访问具体的像素。同时，我也顺便实现了Count和Where两个扩展方法。Count和Where两个扩展方法同时提供了指针版本和非指针版本。
然后，编写类 Rgb24ImageClassHelper：
Rgb24ImageClassHelper.cs
2 using System.Collections.Generic;
3 using System.Text;
4
5 namespace Orc.SmartImage
6 {
7 using TPixel = Rgb24;
8 using TCache = System.Int32;
9 using TKernel = System.Int32;
10
11 public static partial class Rgb24ImageClassHelper
12 {
13 #region include "ImageClassHelper_Template.cs"
14 #endregion
15 }
16 }
编译之后，就可以通过Lambda表达式通过指针来访问 UnmanagedImage<Rgb24> 实例中的像素。例子&性能测试为：
例子与性能测试代码
2
3 // 将每个像素的Blue值改为 50
4
5 CodeTimer.Time("ForEachByLambdaWithPointer-" + imgName, 1, () =>
6 {
7 rgb24.ForEach((Rgb24* p) => { p->Blue = 50; });
8 Console.WriteLine(rgb24.Start->Blue);
9 });
10
11 CodeTimer.Time("ForEachByPointer-" + imgName, 1, () =>
12 {
13 Rgb24* start = rgb24.Start;
14 Rgb24* end = rgb24.Start + rgb24.Length;
15 while (start != end)
16 {
17 start->Blue = 50;
18 ++start;
19 }
20 Console.WriteLine(rgb24.Start->Blue);
21 });
22
23 CodeTimer.Time("CountByLambdaWithPointer-" + imgName, 1, () =>
24 {
25 Console.WriteLine(rgb24.Count((Rgb24* p) => { return p->Blue > 50; }));
26 });
27
28 CodeTimer.Time("CountByLambdaWithValue-" + imgName, 1, () =>
29 {
30 Console.WriteLine(rgb24.Count((Rgb24 c) => { return c.Blue > 50; }));
31 });
32
33 CodeTimer.Time("WhereByLambdaWithPointer-" + imgName, 1, () =>
34 {
35 Console.WriteLine(rgb24.Where((Rgb24* p) => { return p->Blue > 50; }).Count);
36 });
37
38 CodeTimer.Time("WhereByLambdaWithValue-" + imgName, 1, () =>
39 {
40 Console.WriteLine(rgb24.Where((Rgb24 c) => { return c.Blue > 50; }).Count);
41 });
测试结果：
测试结果
2 50
3 Time Elapsed: 210ms
4 CPU Cycles: 333,752,386
5 Gen 0: 0
6 Gen 1: 0
7 Gen 2: 0
8
9 ForEachByPointer-5000_6000_24
10 50
11 Time Elapsed: 76ms
12 CPU Cycles: 116,868,697
13 Gen 0: 0
14 Gen 1: 0
15 Gen 2: 0
16
17 CountByLambdaWithPointer-5000_6000_24
18 0
19 Time Elapsed: 249ms
20 CPU Cycles: 425,180,283
21 Gen 0: 0
22 Gen 1: 0
23 Gen 2: 0
24
25 CountByLambdaWithValue-5000_6000_24
26 0
27 Time Elapsed: 484ms
28 CPU Cycles: 850,295,952
29 Gen 0: 0
30 Gen 1: 0
31 Gen 2: 0
32
33 WhereByLambdaWithPointer-5000_6000_24
34 0
35 Time Elapsed: 242ms
36 CPU Cycles: 425,229,156
37 Gen 0: 0
38 Gen 1: 0
39 Gen 2: 0
40
41 WhereByLambdaWithValue-5000_6000_24
42 0
43 Time Elapsed: 496ms
44 CPU Cycles: 855,667,758
45 Gen 0: 0
46 Gen 1: 0
47 Gen 2: 0
可见：使用Lambda表达式通过指针来访问像素比使用指针直接访问像素慢，大概速度是后者的 1/2 - 1/3 。而使用Lambda表达式通过值来访问像素比使用Lambda表达式通过指针来访问像素要慢。大概速度是后者的1/2。虽然速度慢下来了，但对于性能不攸关的地方，这样处理还是值得的——使用Lambda表达式可以让代码更简洁更优雅！
好了，现在，类C，OO，泛型/模板，Lambda表达式就全揉在一起了，至于具体怎么用，就看具体情况下的权衡取舍了。如果再玩玩Dynamic，大概会有更有趣的玩法。
现在看来，C#真是太NB了！通吃啊！
