C# 指標記憶體控制Marshal記憶體資料儲存原理分析

int val = 10;
 
unsafe
{
    int* p = &val;  //&val用於獲取val變數的記憶體地址，*p為int型別指標、用於間接存取val變數
 
    *p *= *p;       //通過指標修改變數值（執行此操作後 val 變數值將會變成 100）
}

string val = "ABC";
 
unsafe
{
    fixed (char* p = val)   //fixed用於禁止垃圾回收器重定向可移動的變數，可理解為鎖定參照型別物件
    {
        *p = 'D';           //通過指標修改變數值（執行此操作後 val 變數值將會變成 "DBC"）
        p[2] = 'E';         //通過指標修改變數值（執行此操作後 val 變數值將會變成 "DBE"）
        int* p2 = (int*)p;  //將char型別的指標轉換成int型別的指標
    }
}

double[] array = { 0.1, 1.5, 2.3 };
 
unsafe
{
    fixed (double* p = &array[2])
    {
        *p = 0.2;           //通過指標修改變數值（執行此操作後 array 變數值將會變成{ 0.1, 1.5, 0.2 }）
    }
}

User val = new User() { age = 25 };
 
unsafe
{
    fixed (int* p = &val.age)   //fixed用於禁止垃圾回收器重定向可移動的變數，可理解為鎖定參照型別物件
    {
        *p = *p + 1;            //通過指標修改變數值（執行此操作後 val.age 變數值將會變成 26）
    }
}
 
/*
public class User
{
    public string name;
    public int age;
}
*/

char val = 'A';
 
unsafe
{
    int valAdd = (int)&val;             //獲取val變數的記憶體地址，並將地址轉換成十進位制數
 
    //IntPtr address = (IntPtr)123;     //選擇一個記憶體地址(可以是任何一個變數的記憶體地址)
    IntPtr address = (IntPtr)valAdd;    //選擇一個記憶體地址(暫使用val變數的記憶體地址做測試)
                                    
    byte* p = (byte*)address;           //將指定的記憶體地址轉換成byte型別的指標（如果指定的記憶體地址不可操的話、那操作時則會報異常「嘗試讀取或寫入受保護的記憶體。這通常指示其他記憶體已損壞。」）
    byte* p2 = (byte*)2147483647;       //還可通過十進位制的方式選擇記憶體地址
    byte* p3 = (byte*)0x7fffffff;       //還可通過十六進位制的方式選擇記憶體地址
                                        
    *p = (byte)'B';                     //通過指標修改變數值（執行此操作後 val 變數值將會變成 'B'）
}

int valInt = 10;        //定義一個int型別的測試val
char valChar = 'A';     //定義一個char型別的測試val
 
int* pInt = &valInt;    //定義一個int*型別的指標
char* pChar = &valChar; //定義一個char*型別的指標
 
void* p1 = pInt;        //void*可以用於儲存任意型別的指標
void* p2 = pChar;       //void*可以用於儲存任意型別的指標
 
pInt = (int*)p2;        //將void*指標轉換成int*型別的指標 (#需要注意一點：因為都是byte資料、所以不會報轉換失敗異常)
pChar = (char*)p1;      //將void*指標轉換成char*型別的指標(#需要注意一點：因為都是byte資料、所以不會報轉換失敗異常)

unsafe
{
    int* intBlock = stackalloc int[100];
    char* charBlock = stackalloc char[100];
}

using System.Runtime.InteropServices;
 
//int length = 1024;                //定義需要申請的記憶體塊大小(1KB)
int length = 1024 * 1024 * 1024;    //定義需要申請的記憶體塊大小(1GB)
IntPtr address = Marshal.AllocHGlobal(length);                //從非託管記憶體中申請記憶體空間，並返會該記憶體塊的地址 (單位：位元組)
                                                              //相當於byte[length]
                                                              //注意：申請記憶體空間不會立即在工作管理員中顯示記憶體佔用情況
try
{
    #region Marshal - 寫入
    {
        Marshal.WriteByte(address, 111);                      //修改第一個byte中的資料
        Marshal.WriteByte(address, 0, 111);                   //修改第一個byte中的資料
        Marshal.WriteByte(address, 1, 222);                   //修改第二個byte中的資料
        Marshal.WriteByte(address, length - 1, 255);          //修改最後一個byte中的資料 (#此處需要注意，如果定義的偏移量超出則會誤修改其他變數的資料)
    }
    #endregion
 
    #region Marshal - 讀取
    {
        int offset = length - 1;    //定義讀取最後一個byte的內容
 
        byte buffer0 = Marshal.ReadByte(address);             //讀取第一個byte中的資料
        byte buffer1 = Marshal.ReadByte(address, 0);          //讀取第一個byte中的資料
        byte buffer2 = Marshal.ReadByte(address, 1);          //讀取第二個byte中的資料
        byte buffer3 = Marshal.ReadByte(address, length - 1); //讀取最後一個byte中的資料
    }
    #endregion
 
    #region Marshal - 陣列資料寫入到目標記憶體塊中
    {
        //source可以是byte[]、也可以是int[]、char[]...
        byte[] source = new byte[] { 1, 2, 3 };
 
        //將source變數的陣列資料拷貝到address記憶體塊中
        Marshal.Copy(source: source,
            startIndex: 0,          //從source的第一個item開始
            length: 3,              //選擇source的3個item
            destination: address);  //選擇儲存的目標 (會寫到address記憶體塊的開頭處)
    }
    #endregion
 
    #region Marshal - 記憶體塊資料讀取到目標陣列中
    {
        //dest可以是byte[]、也可以是int[]、char[]...
        byte[] dest = new byte[5];
 
        Marshal.Copy(source: address,
            destination: dest,      //#注意：目標陣列不能為空、且需要有足夠的空間可接收資料
            startIndex: 1,          //從dest陣列的第二個item開始
            length: 3);             //將address記憶體塊的前3個item寫入到dest陣列中
    }
    #endregion
 
    unsafe
    {
        int[] array = new int[5] { 1, 2, 3, 4, 5 };
 
        int* p = (int*)Marshal.UnsafeAddrOfPinnedArrayElement(array, 1);    //獲取陣列第二個item的記憶體地址、並轉換成int型別的指標
        char* p2 = (char*)Marshal.UnsafeAddrOfPinnedArrayElement(array, 1); //獲取陣列第二個item的記憶體地址、並轉換成char型別的指標
    }
}
finally
{
    Marshal.FreeHGlobal(address);   //釋放非託管記憶體中分配出的記憶體 (釋放後可立即騰出空間給系統複用)
}