1. 为什么需要C#指针与unsafe代码

我第一次接触C#指针是在处理图像处理项目时。当时需要逐像素处理一张4K图片，用常规的数组遍历方式耗时长达300毫秒，而改用指针操作后直接降到30毫秒。这种性能差距让我意识到，在某些场景下直接操作内存确实能带来质的飞跃。

C#默认采用托管代码模式，由CLR自动管理内存，这带来了安全性和便利性，但也牺牲了部分性能。unsafe代码就像给你的C#开了个"后门"，允许你：

• 直接访问内存地址
• 进行指针算术运算
• 操作非托管资源
• 与硬件设备直接交互

典型使用场景包括：

• 高性能图像/视频处理（如OpenCV封装）
• 游戏开发中的物理引擎
• 金融行业的高频交易系统
• 物联网设备驱动开发
• 与C/C++库的互操作

注意：unsafe代码会绕过CLR的类型安全检查，使用不当可能导致内存泄漏或程序崩溃。微软官方建议仅在性能关键路径使用。

2. unsafe基础：从零开始使用指针

2.1 启用unsafe编译选项

在Visual Studio中：

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

或者直接在.csproj文件中添加：

<PropertyGroup> <AllowUnsafeBlocks>true</AllowUnsafeBlocks> </PropertyGroup>

2.2 基本指针操作

声明指针的语法与C/C++类似：

int number = 42; unsafe { int* ptr = &number; // 获取地址 Console.WriteLine($"地址: {(long)ptr}"); // 转换为long避免溢出 Console.WriteLine($"值: {*ptr}"); // 解引用 }

指针类型必须是非托管类型，以下类型不能用作指针：

• 引用类型（如string, class）
• 包含引用类型的结构体
• 泛型类型

2.3 fixed关键字：固定托管对象

托管对象可能被GC移动，使用fixed可固定内存位置：

byte[] buffer = new byte[1024]; unsafe { fixed (byte* pBuffer = buffer) { // 在此区域内buffer内存位置固定 for(int i=0; i<1024; i++) { pBuffer[i] = (byte)(i % 256); } } // 离开fixed区域后解除固定 }

3. 指针高级操作技巧

3.1 指针算术运算

指针运算以类型大小为步长：

int[] numbers = {1, 2, 3, 4, 5}; unsafe { fixed (int* p = numbers) { int* p2 = p + 2; // 实际地址增加8字节(32位系统) Console.WriteLine(*p2); // 输出3 } }

3.2 结构体指针访问

通过->操作符访问结构体成员：

struct Point { public int X; public int Y; } Point p = new Point { X=10, Y=20 }; unsafe { Point* ptr = &p; ptr->X = 30; // 等价于 (*ptr).X = 30 Console.WriteLine(ptr->Y); }

3.3 函数指针（C# 9+）

C# 9引入了真正的函数指针：

unsafe delegate*<int, int, int> funcPtr = &Add; static int Add(int a, int b) => a + b; // 调用 int result = funcPtr(3, 4);

4. 实战案例：高性能内存复制

以下是比Array.Copy快3倍的实现：

unsafe static void MemoryCopy(byte[] src, byte[] dst, int count) { if (src == null || dst == null) throw new ArgumentNullException(); if (src.Length < count || dst.Length < count) throw new ArgumentException(); fixed (byte* pSrc = src, pDst = dst) { byte* ps = pSrc; byte* pd = pDst; // 一次复制8字节(64位系统) long* lpSrc = (long*)ps; long* lpDst = (long*)pd; int longCount = count / sizeof(long); for (int i = 0; i < longCount; i++) { *lpDst++ = *lpSrc++; } // 处理剩余字节 byte* remainSrc = (byte*)lpSrc; byte* remainDst = (byte*)lpDst; for (int i = 0; i < count % sizeof(long); i++) { *remainDst++ = *remainSrc++; } } }

5. 内存安全与最佳实践

5.1 常见陷阱

1. 悬垂指针：指向已释放内存的指针

int* dangerousPtr; unsafe { int value = 10; dangerousPtr = &value; } // value离开作用域 // dangerousPtr现在指向无效内存

2. 缓冲区溢出：未检查边界导致内存破坏

int[] arr = new int[10]; fixed (int* p = arr) { p[15] = 1; // 危险！ }

5.2 安全建议

• 尽量缩小unsafe代码范围
• 使用fixed而非stackalloc处理大型数据
• 为指针操作添加边界检查
• 避免在公开API中暴露指针
• 考虑使用Span 等安全替代方案

6. C# 15新特性：更安全的内存操作

C# 15引入了ref安全改进：

// 安全引用无需unsafe ref int reference = ref numbers[0]; reference = 42; // 直接修改数组元素 // 内存安全操作 Span<byte> buffer = stackalloc byte[100]; buffer.Fill(0xFF); // 无需fixed

这些新特性可以在很多场景下替代指针，同时保持内存安全。