闲谈.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<T> where T : struct
    {
        public T Width;
        public T Height;

        public Size(T width, T height)
        {
            Width = width;
            Height = height;
        }

        public static Boolean operator ==(Size<T> lhs, Size<T> rhs)
        {
            return lhs.Equals(rhs);
        }

        public static Boolean operator !=(Size<T> lhs, Size<T> rhs)
        {
            return !lhs.Equals(rhs);
        }
    }

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

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

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

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

    unsafe struct S3
    {
        public Size<Int32> 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<Int32>* p = &size)
            {
            }
        }
    }

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

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

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