重新认识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

 1  using  TPixel  =  System.Byte; 
 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

 1  using  System; 
 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> 实例中的像素。例子&性能测试为：

例子与性能测试代码

 1  Rgb24Image rgb24  =   new  Rgb24Image(map); 
 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  });

 

    测试结果：

测试结果

 1  ForEachByLambdaWithPointer - 5000_6000_24 
 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了！通吃啊！