在 C# 中，不安全代码（Unsafe Code）指的是允许你直接访问内存并操作指针的代码。默认情况下，C# 是一种安全语言，它会避免直接操作内存和指针，从而保护程序免受内存泄漏、缓冲区溢出等潜在问题。然而，在某些情况下，特别是处理性能密集型应用时，可能需要使用不安全代码来提高效率。

---

1. 什么是不安全代码？

不安全代码指的是允许使用指针和内存操作的代码，通常需要使用 unsafe 关键字。通过这种方式，C# 程序员可以绕过托管环境的内存管理机制，直接操作内存，从而提高性能，尤其是在处理底层数据（如数组、内存块）时。

在不安全代码中，你可以：

• 使用指针来直接操作内存。
• 使用固定内存（fixed 关键字）来防止 GC 对内存进行回收。

✅ 安全与不安全的区别：

• 安全代码：编译器会检查所有的类型和内存边界。
• 不安全代码：允许指针运算，绕过这些检查。

---

2. 如何编写不安全代码？

🔹 语法

要在 C# 中编写不安全代码，你需要：

1. 使用 unsafe 关键字来标识不安全代码块。
2. 使用指针和 * 运算符进行内存访问。
3. 使用 fixed 关键字来锁定内存块，防止垃圾回收。

示例：使用 unsafe 关键字

using System;

class UnsafeExample
{
    public unsafe static void Main()
    {
        int num = 10;
        int* p = #  // 获取 num 的指针

        Console.WriteLine("num 的值: " + *p);  // 使用指针输出 num 的值

        *p = 20;  // 通过指针修改 num 的值
        Console.WriteLine("修改后的 num 值: " + num);  // 输出 20
    }
}

编译指令：

使用不安全代码时，需要在项目中启用不安全代码。在 Visual Studio 中：

1. 右键项目 -> 属性。
2. 选择 生成 标签页。
3. 勾选 允许不安全代码。

在命令行编译时，可以使用 /unsafe 开关：

csc /unsafe UnsafeExample.cs

---

3. 使用 fixed 锁定内存

托管代码中，垃圾回收器（GC）会在后台回收不再使用的内存，因此如果你尝试在数组或字符串上获取指针，GC 可能会移动这些数据，这会导致指针失效。在不安全代码中，使用 fixed 关键字可以锁定数组，避免 GC 的回收操作。

示例：锁定数组

using System;

class UnsafeExample
{
    public unsafe static void Main()
    {
        int[] arr = new int[] { 1, 2, 3, 4, 5 };

        fixed (int* p = arr)  // 锁定数组的内存
        {
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine("arr[" + i + "] = " + *(p + i));  // 通过指针访问数组
            }
        }
    }
}

---

4. 指针运算与数组访问

在不安全代码中，可以使用指针进行指针运算，直接访问内存位置，这对于优化性能非常重要。

示例：指针运算

using System;

class UnsafeExample
{
    public unsafe static void Main()
    {
        int[] arr = new int[] { 10, 20, 30, 40, 50 };

        fixed (int* p = arr)
        {
            int* p0 = p;  // 获取数组第一个元素的指针

            // 通过指针运算访问数组元素
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine("arr[" + i + "] = " + *(p0 + i));  // 指针加法
            }
        }
    }
}

---

5. 不安全代码的常见应用

1. 性能优化：处理大数据量时，指针和内存操作可能比常规数组访问更高效。
2. 互操作性：在与非托管代码（如 C/C++ 库）交互时，不安全代码可以简化数据交换。
3. 低级别内存操作：如实现高效的内存池、内存拷贝等操作。

---

6. 注意事项和风险

不安全代码虽然提供了更高的灵活性和性能，但也伴随一定的风险：

1. 内存泄漏：指针操作不当可能导致内存未释放，导致内存泄漏。
2. 缓冲区溢出：不小心访问非法内存区域可能引发程序崩溃或数据破坏。
3. GC 问题：由于涉及原生内存，可能影响垃圾回收的正常操作。
4. 难以调试：指针运算等操作容易出错且难以调试。

---

7. 使用不安全代码的实际场景

示例：实现高效的内存池

using System;

class MemoryPool
{
    private int[] pool;
    private int size;

    public MemoryPool(int size)
    {
        pool = new int[size];
        this.size = size;
    }

    public unsafe int* GetMemory()
    {
        fixed (int* p = pool)
        {
            return p;
        }
    }
}

class Program
{
    public unsafe static void Main()
    {
        MemoryPool memoryPool = new MemoryPool(100);
        int* memory = memoryPool.GetMemory();

        // 直接通过指针操作内存
        for (int i = 0; i < 100; i++)
        {
            *(memory + i) = i;
        }

        // 输出池中的值
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(*(memory + i));
        }
    }
}

---

8. 不安全代码与 P/Invoke 和互操作

在与 C/C++ 或其他原生代码库交互时，可以通过不安全代码更高效地传递数据结构。常见的用法是使用 P/Invoke 来调用外部 API，同时将托管内存与非托管内存进行转换。

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

    public static void Main()
    {
        IntPtr moduleHandle = IntPtr.Zero;  // 假设已加载模块
        IntPtr functionAddress = GetProcAddress(moduleHandle, "FunctionName");

        Console.WriteLine("Function address: " + functionAddress);
    }
}

---

延伸阅读

• 📘 Microsoft 官方文档 – 不安全代码
• 📘 P/Invoke 文档 – 使用不安全代码与外部 API 交互

---

更多详细内容请关注其他相关文章！