闲谈.Net类型之public的不public，fixed的不能fixed-白红宇

以前写过《》一文。今天，就再来个语言游戏：public 的不public，fixed 的不能 fixed。本文将构造一个古怪类型：public字段无法访问，标了fixed关键字却无法fixed。

（1）从 fixed 说起

fixed 的经典用法是取分配到托管堆上的值类型或值类型数组的地址，如：

public class Test    {        private int Value;        private Int32[] Array = new Int32[3];        public unsafe void Foo()        {            fixed (int* p = &Value)            {                *p = 30;            }            fixed (Int32* pArray = Array)            {                pArray[0] = 30;            }        }    }

为什么要fixed呢？山不转水转，有GC存在，随时可能把它所占的内存搬位置。fixed 就是告诉GC，这一块内存正被指针操作，别动。

下面是 fixed 的另一种用法。在C中，我们可以在 struct 中嵌入数组，如：

typedef struct S{    int buffer[4];} S;

在C#下，如果像下面这个写法，所得到的 buffer 实际上是在托管堆上，S本身只存储了到buffer 的一个引用。

struct S{     public int[] buffer = new int[3];}

要想实现和C一样在值类型内创建固定大小的内存，就必须用 fixed 关键字：

unsafe struct S    {        public fixed int buffer[3];    }

上面的 buffer 就是一个指针了。假设有 S 的实例s，当在托管堆上时，要使用 s.buffer 就必须先将 s fixed，如果不是在托管堆上，就不用fixed，参见代码：

public unsafe class Example    {        S field = new S();        private bool example1()        {            // ERROR            return field.buffer[2] == 0;        }        private bool example2()        {            // OK            fixed (S* p = &field)            {                return (p->buffer[2] == 0);            }        }        private S example1()        {            // OK            S s = new S();            s.buffer[2] = 0;            return s;        }    }

遗憾的是，上面fixed的用法（在值类型内创建固定大小的内存）只支持几个基本类型：bool、byte、 char、 short、int、long、sbyte、ushort、uint、ulong、float 或 double。

如果想使用其它值类型，怎么办呢？

通过反编译我们看到这里的fixed实际是个语法糖：

下面，我们来模拟它，在值类型内部创建一个fixed不支持的类型的内存块。

unsafe struct S2    {        public Block block;        [StructLayout(LayoutKind.Sequential, Size = 24)]        public struct Block        {            public Rgb24 Val0;        }    }    public unsafe class S2Example    {        S2 S = new S2();        private void example1()        {            fixed(S2* p = &S)            {                (&(p->block.Val0))[2].Blue = 25;            }        }    }

（2）托管类型

通过对 fixed 的研究，发现了一个很有趣的事情。我以前一直以为，只要是值类型都可以用指针指：在托管堆里的fixed一下即可。今天发现不是这样的，有一些值类型是无法使用指针指的。

什么类型呢？属于托管类型（managed type）的值类型。

.net 里的类型可分为值类型和引用类型，也可以分为托管类型和非托管类型。这两种说法有什么区别呢？我画个图来表示：

引用类型一定是托管类型，但是值类型不一定是非托管类型。只有非托管类型才能用 unsafe 指针操作，托管类型不能。

那么，属于托管类型的值类型有哪些呢？

目前我只发现了两种：

（1）泛型值类型！

（2）字段或字段的字段或字段的字段的字段（……）是托管类型！

例如：

public struct Size
     
       where T : struct    {        public T Width;        public T Height;        public Size(T width, T height)        {            Width = width;            Height = height;        }        public static Boolean operator ==(Size
      
        lhs, Size
       
         rhs)        {            return lhs.Equals(rhs);        }        public static Boolean operator !=(Size
        
          lhs, Size
         
           rhs)        {            return !lhs.Equals(rhs);        }    }

它是值类型，但是它是在运行期建立起来的类型，在编译时它是不存在的！这样的类型无法用指针操作。

public unsafe class SizeTExample    {        private void example1()        {            Size
     
       size = new Size
      
       ();            //Error            Size
       
        * p = &size;            p->Width = 200;        }    }

（3）Public的不public，fixed 的不 fixed

有了上面的讨论，下面，我们来构造一个奇怪的类型：

unsafe struct S3    {        public Size
     
       size;        public fixed byte buffer[4];    }

这个类型有个字段size是泛型值类型 Size<Int32>，这就导致了S3本身是值类型，也是托管类型。是托管类型的话，就不能进行指针操作等unsafe操作。无法fixed，无法 sizeof等等。无法fixed的话，它标志为 fixed byte 的 buffer 就无法访问。

public unsafe class S3Example    {        private void example1()        {            S3 S = new S3();            //Error            fixed (Size
     
      * p = &size)            {            }        }    }

这样的话，我们就成功构造出一个有public字段但是无法访问，有fixed内存区但是无法fixed的古怪类型。

当然，还有更简单的做法：

unsafe struct S4    {        public Object obj;        public fixed byte buffer[4];    }

本文转自xiaotie博客园博客，原文链接http://www.cnblogs.com/xiaotie/archive/2012/12/31/2840232.html如需转载请自行联系原作者

xiaotie 集异璧实验室(GEBLAB)