异常教程

C# 不安全代码（一文讲透）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
  • 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在 C# 的世界中，类型安全与内存管理通常被视为语言的“安全护盾”——它让开发者无需直接操作内存，就能高效地构建复杂的应用程序。然而，当需要与底层系统交互、优化性能，或是处理特定硬件接口时，C# 提供了“不安全代码”这一功能。本文将从编程初学者的角度出发，逐步解析 C# 不安全代码的核心概念、应用场景及潜在风险，帮助开发者在安全与灵活之间找到平衡点。

什么是不安全代码？

不安全代码（Unsafe Code） 是 C# 中允许直接操作内存、使用指针或访问非托管资源的代码块。尽管名字带有“不安全”，但它并非完全不可控，而是通过编译器和运行时的约束来降低风险。

类比理解：驾驶赛车 vs. 驾驶家用轿车

可以将 C# 的普通代码比作家用轿车——它提供了完善的驾驶辅助系统（如类型检查、垃圾回收机制），确保驾驶（开发）过程的安全性。而不安全代码则像是赛车：虽然允许开发者直接控制引擎（内存和指针），但需要具备更高的技术能力，否则可能引发严重事故（程序崩溃或内存泄漏）。

不安全代码的核心特性

1. 指针（Pointers）

指针是不安全代码中最基础的工具，它存储了一个变量在内存中的地址。与普通变量不同，指针可以直接操作内存，但这也意味着更高的责任。

指针的声明与使用

在 C# 中，必须通过 unsafe 关键字标记代码块，并在编译时启用不安全代码支持（如通过 Visual Studio 的项目属性设置）。

unsafe  
{  
    int number = 10;  
    int* pointer = &number; // 取变量的地址  
    Console.WriteLine($"Address: {pointer}");  
    Console.WriteLine($"Value: {(*pointer)}"); // 通过指针访问值  
}

指针的特性

  • 直接内存访问：指针可以跳过类型安全检查，直接读写内存地址。
  • 风险与责任：若指针指向无效地址（如已释放的内存），会导致程序崩溃或未定义行为。

2. 结构体与联合体

在 C# 中，struct 默认是值类型，但通过 unsafe 可以实现类似 C 语言的 联合体（Union），允许多个字段共享同一块内存空间。

联合体的示例

unsafe struct DataUnion  
{  
    public int integerValue;  
    public float floatValue;  
    public char charArray[4]; // 固定大小的数组  
}  

unsafe  
{  
    DataUnion data;  
    data.integerValue = 0x41424344; // 写入整数  
    Console.WriteLine($"As chars: {data.charArray[0]} {data.charArray[1]}"); // 输出 "A B"  
}

场景：解析二进制数据

联合体在解析网络协议（如 TCP/IP 头部）或处理硬件寄存器时非常有用，因为它允许开发者直接操作内存布局。

3. 固定内存（Fixed）

由于 C# 的垃圾回收机制（GC）会动态移动对象在内存中的位置，直接使用指针可能存在风险。此时需通过 fixed 关键字“固定”内存地址：

unsafe  
{  
    string text = "Hello World";  
    fixed (char* ptr = text)  
    {  
        Console.WriteLine($"First character: {ptr[0]}"); // 输出 "H"  
    } // 固定块结束时，GC 可以再次移动内存  
}

注意事项

  • fixed 仅适用于固定数组或固定字符串的起始地址，且块外无法访问指针。
  • 避免在固定块外保留指针，否则可能导致悬空指针（Dangling Pointer）。

不安全代码的常见应用场景

场景 1：高性能计算

在数值计算、图像处理等场景中，通过指针直接操作内存可以显著提升性能。例如，矩阵乘法的优化：

unsafe void MultiplyMatrices(int[,] a, int[,] b, int[,] result)  
{  
    fixed (int* ptrA = a, ptrB = b, ptrResult = result)  
    {  
        for (int i = 0; i < a.GetLength(0); i++)  
        {  
            for (int j = 0; j < b.GetLength(1); j++)  
            {  
                int sum = 0;  
                for (int k = 0; k < a.GetLength(1); k++)  
                {  
                    sum += ptrA[i * a.GetLength(1) + k] * ptrB[k * b.GetLength(1) + j];  
                }  
                ptrResult[i * result.GetLength(1) + j] = sum;  
            }  
        }  
    }  
}

性能对比

与普通循环相比，指针操作减少了索引计算的开销，尤其在大规模数据处理时效果显著。

场景 2：与原生代码交互

当需要调用 C/C++ 编写的 DLL 或与硬件直接通信时，不安全代码能简化参数传递。例如，通过 DllImport 调用 Win32 API：

using System.Runtime.InteropServices;  

unsafe class NativeMethods  
{  
    [DllImport("user32.dll")]  
    public static extern bool ShowCursor(int show);  

    // 直接传递指针给 C 函数  
    [DllImport("kernel32.dll")]  
    public static extern void RtlMoveMemory(IntPtr dest, IntPtr src, int size);  
}  

unsafe void CopyMemory()  
{  
    int source = 0x12345678;  
    int target;  
    NativeMethods.RtlMoveMemory((IntPtr)(&target), (IntPtr)(&source), sizeof(int));  
    Console.WriteLine($"Copied value: {target}"); // 输出 "305419896"  
}

使用不安全代码的风险与最佳实践

风险 1：内存泄漏与崩溃

直接操作内存可能导致以下问题：

  • 悬空指针：指针指向已释放的内存。
  • 内存越界：访问超出数组或结构体边界的内存区域。

风险示例

unsafe  
{  
    int* invalidPtr = stackalloc int[10]; // 分配栈内存  
    // ...  
    // 若此处未正确释放或保存指针，可能导致后续访问出错  
}

风险 2：类型安全失效

通过指针强制转换类型可能导致数据损坏。例如：

unsafe  
{  
    double d = 3.14;  
    int* p = (int*)&d; // 将 double 地址强制转为 int 指针  
    Console.WriteLine(*p); // 输出不确定的值，可能引发未定义行为  
}

最佳实践

  1. 最小化不安全代码范围
    将 unsafe 代码块限制在必要功能内，并通过方法封装隔离风险。

  2. 使用 stackalloc 替代堆分配
    stackalloc 在栈上分配内存，无需垃圾回收，但需注意栈大小限制（默认为 1MB）。

    unsafe  
{  
    int* buffer = stackalloc int[100]; // 分配栈内存  
    // ...  
} // 内存自动释放

  3. 避免跨线程操作指针
    多线程环境下，指针可能因内存地址变化而失效。

  4. 使用 Marshal 类辅助内存操作
    System.Runtime.InteropServices.Marshal 提供了安全的内存拷贝、释放等方法。

不安全代码与内存管理

垃圾回收（GC）的影响

C# 的 GC 会自动管理托管内存（Heap），但不安全代码操作的栈内存（Stack）和非托管内存（如 Marshal.AllocHGlobal）需手动管理：

unsafe  
{  
    IntPtr ptr = Marshal.AllocHGlobal(1024); // 分配非托管内存  
    // ...  
    Marshal.FreeHGlobal(ptr); // 手动释放  
}

内存泄漏场景

若忘记释放非托管内存，可能导致程序占用过多资源。

指针与对象引用的差异

C# 中的对象引用是“智能指针”，由 GC 管理生命周期。而不安全代码中的指针仅是内存地址，不会触发 GC 的引用计数。

// 托管对象引用  
MyClass obj = new MyClass();  

// 不安全指针（仅指向内存地址）  
unsafe {  
    int* ptr = stackalloc int[1];  
} // 指针失效，内存自动释放

总结与展望

C# 的不安全代码如同一把双刃剑：它赋予开发者直接操作内存的自由，但也要求对底层机制有深刻理解。对于初学者，建议在掌握类型安全开发、内存模型及 GC 原理后再尝试使用不安全代码。

通过合理使用指针、联合体、fixed 和 stackalloc，开发者可以在性能优化、系统级编程等领域突破语言的常规限制。然而，始终需铭记：不安全代码的“不安全”不在于语言本身，而在于使用者对内存管理的责任。

在未来的开发中，随着 C# 不断引入新特性（如 Span<T> 和 Memory<T>），部分不安全场景可通过安全方式替代。但掌握不安全代码的核心思想，仍是深入理解编程本质的重要一环。

关键词布局检查：C# 不安全代码、指针、内存操作、联合体、固定内存、垃圾回收、性能优化、非托管资源
（注：以上为人工模拟的关键词分布，实际文章中关键词已自然融入内容）

最新发布

查看更多文章