深度分析C#中Array的存储结构

1         int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
2 
3         for (int j = 0; j 10; j++ )
4         {
5            Console.WriteLine("Element[{0}] = {1}", j, myIntArray[j]);
6         }

1         public static unsafe Array CreateInstance(Type elementType, int length)
2         {
3             RuntimeType? t = elementType.UnderlyingSystemType as RuntimeType;
4 
5             return InternalCreate(t, 1, &length, null);
6         }

 1         private static unsafe Array InternalCreate(RuntimeType elementType, int rank, int* pLengths, int* pLowerBounds)
 2         {
 3             if (rank == 1)
 4             {
 5                 return RuntimeImports.RhNewArray(elementType.MakeArrayType().TypeHandle.ToEETypePtr(), pLengths[0]);
 6             }
 7             else
 8             {
 9                 int* pImmutableLengths = stackalloc int[rank];
10                 
11                 for (int i = 0; i  pLengths[i];
12 
13                 return NewMultiDimArray(elementType.MakeArrayType(rank).TypeHandle.ToEETypePtr(), pImmutableLengths, rank);
14             }
15         }

1         [MethodImpl(MethodImplOptions.InternalCall)]

2         [RuntimeImport(RuntimeLibrary, "RhNewArray")]
3         private static extern unsafe Array RhNewArray(MethodTable* pEEType, int length);
4 
5         internal static unsafe Array RhNewArray(EETypePtr pEEType, int length) => RhNewArray(pEEType.ToPointer(), length);

(1)、[MethodImpl(MethodImplOptions.InternalCall)] 
　　　指示编译器生成的方法体会被一个外部实现取代，而该外部实现通常由运行时环境提供。

(2)、[RuntimeImport(RuntimeLibrary, "RhNewArray")] 
　　  这是一个自定义的特性，在项目中定义的用于指示运行时导入的特性。 

在C#中，使用属性标记运行时导入的位置通常是为了提供额外的元数据和信息，以告诉编译器和运行时环境如何正确地处理外部方法的调用。

(1)、元数据信息：运行时导入的位置可能包括一些元数据信息，如函数名称、库名称、调用约定等。 
　　  使用属性可以将这些信息嵌入到C#代码中，使得代码更加自解释，并提供足够的信息供编译器和运行时使用。 

(2)、优化和安全性：编译器和运行时环境可能会使用属性来进行性能优化或安全性检查。 例如，通过指定调用约定或其他属性，可以帮助编译器生成更有效的代码。
 
(3)、与运行时环境交互：属性可以提供一种与底层运行时环境进行交互的机制。 例如，通过自定义属性，可以向运行时环境传递一些特殊的标志或信息，以影响方法的行为。

(4)、代码维护和可读性：使用属性可以提高代码的可维护性和可读性。 在代码中使用属性来标记运行时导入的位置，使得代码的意图更加清晰，也有助于团队协作。

1         internal unsafe Internal.Runtime.MethodTable* ToPointer()
2         {
3             return (Internal.Runtime.MethodTable*)(void*)_value;
4         }

 1         struct MethodTable
 2         {
 3             // 指向类型的虚方法表（VTable）
 4             IntPtr* VirtualMethodTable;
 5 
 6             // 字段表
 7             FieldInfo* Fields;
 8 
 9             // 接口表
10             InterfaceInfo* Interfaces;
11 
12             // 其他元数据信息...
13         }

 1 #include 
 2 
 3 extern "C" {
 4     struct MethodTable { // 方法表等信息...};
 5     struct Array { // 数组相关信息...};
 6     void* RhNewArray(void* pEEType, int length) {
 7         // 假设存在一个用于对象分配的函数，该函数分配数组的内存
 8         void* rawArrayMemory = AllocationFunction(length * sizeof(Array));
 9         // 将传递的 pEEType 信息保存到数组对象中
10         Array* newArray = static_cast(rawArrayMemory);
11         //为数组对象设置元数据信息
12         newArray->MethodTablePointer = pEEType;
13         return rawArrayMemory;
14     }
15 }

1 void* AllocationFunction(size_t size) {
2     // 使用标准库的 malloc 函数进行内存分配
3     void* memory = malloc(size);
4     //处理内存分配失败的情况
5     ...
6     return memory;
7 }

(1)、请求内存空间： malloc() 根据传递的 size 参数向系统请求一块足够大的内存空间。 

(2)、内存分配：如果系统成功分配了请求的内存块，malloc 会在这块内存中标记已分配的部分，并将其起始地址返回给调用者。 

(3)、返回结果：如果分配成功，malloc 返回一个指向新分配内存的指针。如果分配失败（例如，系统内存不足），则返回 NULL。

(4)、内存对齐：部分系统要求分配的内存是按照特定字节对齐的。因此，malloc 通常会确保返回的内存地址满足系统的对齐要求。 

(5)、初始化内存：malloc 返回的内存通常不会被初始化，即其中的数据可能是未知的。在使用之前，需要通过其他手段对内存进行初始化。 

(6)、内存管理：一些实现可能会使用内部数据结构来跟踪已分配和未分配的内存块，以便在 free 被调用时能够释放相应的内存。

1 int myArray[5]; // 声明一个包含5个整数的数组
2 
3 +------+------+------+------+------+
4 | int0 | int1 | int2 | int3 | int4 |
5 +------+------+------+------+------+

(1)、元素的内存布局：数组的元素在内存中是依次排列的，每个元素占用的内存空间由元素的类型决定。 
　　  例如，一个 int 数组中的每个整数元素通常占用4个字节（32位系统）或8个字节（64位系统）。 

(2)、数组的起始地址：数组的内存分配通常从数组的第一个元素开始。数组的起始地址是数组第一个元素的地址。 

(3)、连续存储：数组的元素在内存中是连续存储的，这意味着数组中的每个元素都直接跟在前一个元素的后面。

1  Array* newArray = static_cast(rawArrayMemory);

1、分配对象头：为数组对象分配对象头，对象头包含一些元数据，如类型指针、同步块索引等信息。 

2、分配数组元素空间：分配存储数组元素的内存块，这是实际存储数组数据的地方。 

3、初始化数组元素：根据数组类型的要求，初始化数组元素。这可能涉及到对元素进行默认初始化，例如将整数数组的每个元素初始化为零。 

4、返回数组引用：返回指向数组对象的引用，使得该数组可以被使用。

1、硬件要求：访问特定类型的数据时，其地址应该是某个值的倍数。 

2、提高访问速度：对齐的内存访问通常比不对齐的访问更加高效。处理器通常能够更快地访问对齐的内存，因为这符合硬件访问模式。 

3、减少内存碎片：内存对齐还有助于减少内存碎片，使得内存的使用更加紧凑。内存碎片可能导致性能下降，因为它可能增加了分配和释放内存的开销。 

4、硬件事务：一些处理器和操作系统支持原子操作，但通常要求数据是按照特定的对齐方式排列的。

1、使用操作系统的内存分配函数：使用操作系统提供的内存分配函数来分配托管堆上的内存。在Windows上可能是HeapAlloc。 

2、对齐方式的指定：在调用内存分配函数时，会指定所需的对齐方式。通常是以字节为单位的对齐值。常见的对齐值包括4字节、8字节等。 

3、内存块的对齐：内存分配函数返回的内存块通常是按照指定的对齐方式进行对齐的。CLR确保返回的内存块的起始地址符合对齐规则。 

4、对齐规则的维护：维护对齐规则的信息，确保在托管堆上分配和释放的内存块都符合相同的对齐方式。 

5、内存对齐的优化：对内存对齐进行一些优化，以提高访问效率。例如，它可以在对象的布局中考虑对齐规则，以减少内存碎片。