闲谈.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];
}
