C#(含Unity)unsafe指针快速反射第一篇（字段篇 ）

C#反射很慢是吧？快速反射有很多种做法，典型的有【emit动态编译】、【Expression表达式树动态创建匿名方法】这两种做法，但这两种做法都依赖于动态编译，我们做Unity移动开发的小伙伴肯定知道，iOS平台不允许JIT，导致动态编译无法完成。而今天我给大家带来一种指针反射的做法，效果很好很强大，不需要任何动态编译，性能甚至和emit差不多。

C#(含Unity)unsafe指针快速反射第二篇（属性篇 ）

C#(含Unity)unsafe指针快速反射第三篇（数组篇 ）

C#(含Unity)unsafe指针快速反射第四篇（整合篇 ）

C#(含Unity)unsafe指针快速反射第五篇（性能比较篇 ）

Unity3D（已完成iL2cpp和Mono的编译）请访问：smopu/unity3d_quick_reflection: 在unity3D中使用指针进行快速反射 (github.com)

.Net Framework 和.Net Core请访问：smopu/CSharp_QuickReflection: C# .Net Framework Quick Reflection 快速反射 (github.com)

这是个功能实现完整的Unity指针反射库，里面已经包含了大量示例

Unity指针反射库的测试用例

本系列分四个篇章，第一篇讲解如何用指针反射字段（Field）的原理，第二篇是用指针反射属性（Property），第三篇是用指针反射数组（Array），第四篇是讲解整个反射工具， 第五篇是跟emit和表达式树做一个统一的性能对比。

每个人性格不一样，有的人喜欢循规蹈矩，有的人喜欢打破陈规，如果存在一个神秘的对象，有的人对它敬而远之，有的人对它感到好奇，如果读者朋友你是前者，那我希望你不要再继续看下去了。如果读者朋友你曾经了解过C#指针操作，那你可能听说过【未公开的C#关键字】，这是一项禁忌的技术，打这些关键字的时候VS IDE都不给你提示。我们取C#指针通常会用到__makeref这个未公开的关键字，但本篇文章教你另一种更加高效、巧妙的方法，绝对原创~

如果您使用的是.Net Framework或者.Net Core，在项目->设置->生成里勾选【允许不安全代码】

然后随便写个类，随便写几个字段，私有公开都无所谓

public class TestClassA
    {
      public double a;
      public int b;
      private long c;
      public string d;
    }

然后跟着我加入下面的代码：

[StructLayout(LayoutKind.Explicit)]
public unsafe class UnsafeTool
{
public delegate void* ObjectToVoidPtr(object obj);
[FieldOffset(0)]
public ObjectToVoidPtr objectToVoidPtr;

[FieldOffset(0)]
Func<object, object> func;

public UnsafeTool()
{
func = Out;
}
object Out(object o) { return o; }
}

StructLayout的命名空间是System.Runtime.InteropServices，它的功能是指定类中字段在对象内存中的排列顺序，如果没有加这个特性(Attribute)，默认的排列顺序相对于LayoutKind.Auto，我们指定为LayoutKind.Explicit，这意味着我们必须用FieldOffset手动指定所有字段的地址偏移量（手动指定地址时，所有引用类型必须保持对齐，64位是8字节对齐，32位是4字节对齐），对于objectToVoidPtr和func变量，它们的地址偏移量都是0字节，也就是说它们共享地址位置。

然后我们在Mian方法中写入下面代码：

    public static unsafe void Main(string[] args)
    {
      UnsafeTool unsafeTool = new UnsafeTool();
      TestClassA testClassA = new TestClassA();
      void* ptr = unsafeTool.objectToVoidPtr(testClassA);

      Console.ReadKey();
    }

现在这里的ptr 就是对象testClassA 地址的指针！有的读者可能不清楚void是什么，它是任意指针，在64位程序中长度为8字节，32位是4字节，它本质就是写着一个地址，可以指向任何内存，而object在IL中可以直接当作void*使用。通过反编译也可看到是把对象推送后直接返回了。

反编译IL代码

事实上，object可以直接当void*来用，但是C#编译不允许通过，这是因为object在GC过程中会改变对象所在的内存地址，这也就导致我们获得了对象的地址以后，对象GC后地址改变，再次取地址则会丢失该对象。所以C#连编译都不允许通过。只能取到没有任何引用类型字段的结构体指针或者基本数据类型指针。

因此，我们每次使用指针反射赋值或获得值的时候都要保证在不创建新的引用对象前提下完成（因为创建堆内存引发GC），但如果在Mono平台或者Unity（unity使用的是Mono，IL2CPP保持和Mono一致）上使用则不需要考虑这个问题，因为Mono的GC不使用分代的算法，内存地址不会改变。

IntPtr是C#指针的另一种表达方式，你可以认为是封装了的void*，sizeof(IntPtr)在64位程序中为8，32位是4，对象都是按照这个规格内存对齐的，我们用指针取值也是如此。C#的引用对象的内存结构是 类型指针+所有字段+1个指针长度的空位。值类型对象就只是所有字段的值。我们可以通过sizeof关键字取得 任何引用类型字段的结构的内存大小 或者基本数据类型的内存大小，对于引用类型，它在栈中永远是一个指针大小，而真正的内存在堆中，我们可以通过这种方式取得对象堆内存大小

public unsafe static int SizeOf(Type type)
    {
      return *((int*)type.TypeHandle.Value + 1);
    }

不过要注意，这个方法只能在.Net Framework和.Net Core中使用，Unity平台需要别的方法，如果读者有更好的方法，请务必在评论区留言。

事实上，我们用指针反射赋值取值，不需要关心对象内存的大小，而是对象字段的内存偏移量，就像我们上面用FieldOffset设置字段的偏移量反过来，我们现在要动态地取到它们。

在.Net Framework和.Net Core中您可以使用如下代码

public unsafe static int GetFieldOffset(FieldInfo fieldInfo)
    {
      var ptr = fieldInfo.FieldHandle.Value;
      ptr = ptr + 4 + sizeof(IntPtr);
      ushort length = *(ushort*)(ptr);
      byte chunkSize = *(byte*)(ptr + 2);
      return length + (chunkSize << 16);
    }

在Unity中直接使用UnsafeUtility.GetFieldOffset方法即可（命名空间Unity.Collections.LowLevel.Unsafe）

然后，我们就可以用指针直接赋值和取值，代码如下

（使用Unity的读者请自行将Main修改成其他方法，把GetFieldOffset改成UnsafeUtility.GetFieldOffset）

public static unsafe void Main(string[] args)
    {
      UnsafeTool unsafeTool = new UnsafeTool();

      TestClassA testClassA = new TestClassA();
      testClassA.a = 2.718281828459;

      byte* ptr = (byte*)unsafeTool.objectToVoidPtr(testClassA);
      ptr += sizeof(void*);
      //取得字段的偏移量
      int offset = GetFieldOffset(testClassA.GetType().GetField(\"a\", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
      ptr += offset;

      //取得字段的值
      double a = *(double*)ptr;
      Console.WriteLine(a);

      //给字段的赋值
      *(double*)ptr = 3.1415926535;
      Console.WriteLine(testClassA.a);

      Console.ReadKey();
    }

执行后，得到的结果如下

执行结果

您可以将“a\”字符串改成其他的字段名进行尝试，比如\”b\”、\”c\”，但是对于字符串\”d\”，我们需要特殊处理，因为字符串是引用类型，包括其他引用类型字段，我们都需要这样处理：将对象地址+引用类型字段偏移量当作void**取值，则取到void*，然后转为object，这里为什么是void**呢？因为void*相当于object，那么object的指针就是void**。我们先把UnsafeTool类里多加些内容，使得我们有把void*转换回object的方法。

   [StructLayout(LayoutKind.Explicit)]
    public unsafe class UnsafeTool
    {
      public delegate void* ObjectToVoidPtr(object obj);
      [FieldOffset(0)]
      public ObjectToVoidPtr objectToVoidPtr;
      [FieldOffset(0)]
      Func<object, object> func;

      public delegate object VoidPtrToObject(void* ptr);
      [FieldOffset(0)]
      public VoidPtrToObject voidPtrToObject;
      [FieldOffset(0)]
      Func<object, object> func2;

      public UnsafeTool()
      {
        func = Out;
        func2 = Out;
      }
      object Out(object o) { return o; }
    }

接下来，我们再把Main方法更改

public static unsafe void Main(string[] args)
    {
      UnsafeTool unsafeTool = new UnsafeTool();

      TestClassA testClassA = new TestClassA();
      testClassA.a = 2.718281828459;
      testClassA.d = \"大家好\";

      byte* objPtr = (byte*)unsafeTool.objectToVoidPtr(testClassA);
      objPtr += sizeof(IntPtr);

      byte* ptr = objPtr;
      //取得字段的偏移量
      int offset = GetFieldOffset(testClassA.GetType().GetField(\"a\", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
      ptr += offset;

      //取得字段的值
      double a = *(double*)ptr;
      Console.WriteLine(a);

      //给字段的赋值
      *(double*)ptr = 3.1415926535;
      Console.WriteLine(testClassA.a);

      ptr = objPtr;
      //取得字段的偏移量
      offset = GetFieldOffset(testClassA.GetType().GetField(\"d\", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
      ptr += offset;

      //取得字段的值
      string d = (string)unsafeTool.voidPtrToObject(*(void**)ptr);
      Console.WriteLine(d);

      //给字段的赋值
      *(IntPtr*)ptr = (IntPtr)unsafeTool.objectToVoidPtr(\"草泥马\");
      Console.WriteLine(testClassA.d);

      Console.ReadKey();
    }

我们将这些偏移量全部保存起来，就能实现高性能的指针反射。这里细心的读者就会提问了，那么结构体的反射操作呢？结构体作为对象的字段时，内存是直接在对象内存内的.如下图所展示的，结构体A的所有字段内嵌到对象A中

内存示例图

因此，结构体的指针反射需要直接内存拷贝，熟悉C++的读者肯定知道memcpy，IL指令对应的是cpblk，在unity中，您可以直接使用Unity.Collections.LowLevel.Unsafe.UnsafeUtility.MemCpy方法。在.Net Framework和.Net Core中您可以使用System.Runtime.CompilerServices.Unsafe.CopyBlock方法。

CopyBlock反编译结果

结构体的指针反射当作作业留给读者朋友们，我在下一篇章：属性反射中给出答案。

最后给出本篇完整代码，方便那些不想看字只想白嫖的读者们：

using System;
using System.Reflection;
using System.Runtime.InteropServices;

namespace UnsafeReflection
{
  public class Class1
  {
    public static unsafe void Main(string[] args)
    {
      UnsafeTool unsafeTool = new UnsafeTool();

      TestClassA testClassA = new TestClassA();
      testClassA.a = 2.718281828459;
      testClassA.d = \"大家好\";

      byte* objPtr = (byte*)unsafeTool.objectToVoidPtr(testClassA);
      objPtr += sizeof(IntPtr);

      byte* ptr = objPtr;
      //取得字段的偏移量
      int offset = GetFieldOffset(testClassA.GetType().GetField(\"a\", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
      ptr += offset;

      //取得字段的值
      double a = *(double*)ptr;
      Console.WriteLine(a);

      //给字段的赋值
      *(double*)ptr = 3.1415926535;
      Console.WriteLine(testClassA.a);

      ptr = objPtr;
      //取得字段的偏移量
      offset = GetFieldOffset(testClassA.GetType().GetField(\"d\", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
      ptr += offset;

      //取得字段的值
      string d = (string)unsafeTool.voidPtrToObject(*(void**)ptr);
      Console.WriteLine(d);

      //给字段的赋值
      *(IntPtr*)ptr = (IntPtr)unsafeTool.objectToVoidPtr(\"草泥马\");
      Console.WriteLine(testClassA.d);

      Console.ReadKey();
    }


    public unsafe static int GetFieldOffset(FieldInfo fieldInfo)
    {
      var ptr = fieldInfo.FieldHandle.Value;
      ptr = ptr + 4 + sizeof(IntPtr);
      ushort length = *(ushort*)(ptr);
      byte chunkSize = *(byte*)(ptr + 2);
      return length + (chunkSize << 16);
    }


    [StructLayout(LayoutKind.Explicit)]
    public class TestClassA
    {
      [FieldOffset(0)]
      public double a;
      [FieldOffset(8)]
      public int b;
      [FieldOffset(16)]
      private long c;
      [FieldOffset(24)]
      public string d;
    }


    [StructLayout(LayoutKind.Explicit)]
    public unsafe class UnsafeTool
    {
      public delegate void* ObjectToVoidPtr(object obj);
      [FieldOffset(0)]
      public ObjectToVoidPtr objectToVoidPtr;
      [FieldOffset(0)]
      Func<object, object> func;

      public delegate object VoidPtrToObject(void* ptr);
      [FieldOffset(0)]
      public VoidPtrToObject voidPtrToObject;
      [FieldOffset(0)]
      Func<object, object> func2;

      public UnsafeTool()
      {
        func = Out;
        func2 = Out;
      }
      object Out(object o) { return o; }
    }


  }
}