.NET(C#) 中使用指针

1、 开启不安全代码支持

要在 C# 项目中使用指针，首先需要在项目设置中启用不安全代码。这通常在项目属性中设置。

1）Visual Studio 设置

在项目上右键属性，在点击 "生成" ,勾选允许不安代码，有些vs中那个选项可能是英文的，需要注意一下，如下图，

2）修改.csproj 文件

在 .csproj 文件中添加以下代码：

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

2、使用 unsafe 关键字

在 C# 中，任何包含指针操作的代码块都需要被 unsafe 关键字标记。这可以是一个方法、一个代码块或整个类。

1）使用unsafe代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
             unsafe
             {
                 int[] numbers = { 10, 20, 30, 40, 50 };
                 // 固定数组，防止垃圾回收器移动它，获取数组的指针
                 fixed (int* p = numbers)
                 {
                     // 输出数组中的每个元素
                     for (int i = 0; i < numbers.Length; i++)
                     {
                         Console.WriteLine("Element {0}: {1}", i, *(p + i));   
                      }
                  }
              }
              Console.ReadKey();
        }
    }
}

 2）使用unsafe关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication
{
    class Program
    {
            // 定义一个标记了 unsafe 的方法
        public unsafe static void UnsafeMethod()
        {
            int value = 10;
            int* pValue = &value; // 获取变量的地址
    
            Console.WriteLine("Value before change: " + value);
            
            // 使用指针修改变量的值
            *pValue = 20;
            Console.WriteLine("Value after change: " + value);
        }
        static void Main(string[] args)
        {
              // 调用 unsafe 方法
              UnsafeMethod();
              Console.ReadKey();
        }
    }
}

3、指针操作

声明指针使用 * 操作符声明指针变量，例如 int* p;  ，获取变量地址：使用 & 操作符获取变量的地址，例如 p = &myVar;。访问指针指向的值使用 * 操作符访问或修改指针指向的值，例如 *p = 5;。 

1）基础操作

使用不安全代码时，程序员负责确保代码的正确性和内存安全性。错误的指针操作可能会导致程序崩溃或数据损坏。fixed 语句限制了垃圾回收器对固定对象的处理，因此应谨慎使用，以免影响性能。

using System;
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {    
             //用指针操作栈上的值类型
             int maxValue = 10;
             int* p = &maxValue;
             *p = 20;
             Console.WriteLine(p->ToString());eadKey();
        }
    }
    //要用指针操作托管堆上的值类型，需要用到 fixed关键字
    public unsafe class Coder
     {
        public int Age;
        public void SetAge(int age)
        {
            fixed (int* p = &Age)
            {
                *p = age;
            }
        }
    }
}

2）分配释放内存

使用指针操作内存时，可以通过 Marshal 类来分配和释放非托管内存。这是因为在 .NET 中，内存管理通常是自动的，但在使用指针进行非托管内存操作时，需要手动处理内存的分配和释放。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
             // 分配非托管内存
              int size = sizeof(int);
             IntPtr pMemory =  System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
     
             try
             {
                 // 将 IntPtr 转换为指针
                 int* pInt = (int*)pMemory;
     
                 // 在分配的内存中存储数据
                 *pInt = 123;
     
                 // 读取内存中的数据
                 Console.WriteLine("Data: " + *pInt);
             }
             finally
             {
                 // 释放非托管内存
                  System.Runtime.InteropServices.Marshal.FreeHGlobal(pMemory);
             }
              Console.ReadKey();
        }
    }

}
             System.Runtime.InteropServices.Marshal.FreeHGlobal(handle);

  3）用IDispose接口管理内存

实现 IDisposable 接口允许你定义一个 Dispose 方法，用于释放类所占用的非托管资源。这是一种确定性的清理方式，可以控制何时释放资源。

   public unsafe class UnmanagedMemory : IDisposable
        {
            public int Count { get; private set; }
            private byte* Handle;
            private bool _disposed = false;
            public UnmanagedMemory(int bytes)
            {
                Handle = (byte*) System.Runtime.InteropServices.Marshal.AllocHGlobal(bytes);
                Count = bytes;
            }
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(true);
            }
            protected virtual void Dispose( bool isDisposing )
            {
                if (_disposed) return;
                if (isDisposing)
                {
                    if (Handle != null)
                    {
                        System.Runtime.InteropServices.Marshal.FreeHGlobal((IntPtr)Handle);
                    }
                }
                _disposed = true;
            }
            ~UnmanagedMemory()
 　         {
 　　           Dispose( false );
 　         }
        }

  使用方法：

 using (UnmanagedMemory memory = new UnmanagedMemory(10))
            {
                int* p = (int*)memory.Handle;
                *p = 20;
                Console.WriteLine(p->ToString());
            }

4）使用stackalloc关键字

stackalloc 关键字用于在栈上分配内存块，通常用于分配小型数组。与在堆上分配内存（如使用 new 关键字）不同，stackalloc 分配的内存不需要垃圾回收，因此可以提高性能。但是，它只应该用于较小的内存分配，因为栈空间相对有限。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
             /// 分配一个大小为 10 的整数数组
            int* array = stackalloc int[10];
    
            // 初始化数组
            for (int i = 0; i < 10; i++)
            {
                array[i] = i;
            }
    
            // 打印数组内容
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(array[i]);
            }
       }
    }

}

4、C# 指针操作的几个缺点

在 C# 中使用指针操作（通常在 unsafe 代码块中进行）确实提供了更直接的内存访问和潜在的性能优势，但它也带来了一些明显的缺点和风险。

1）只能用来操作值类型
指针在 C# 中主要用于操作值类型（如 int, float, char 等）。.NET中，引用类型的内存管理全部是由GC管理的，无法取得其地址，因此，无法用指针来操作引用类型。
2）泛型不支持指针类型
泛型的一个主要优点是提供类型安全。但是，由于指针操作本质上是不安全的，因此 C# 不允许在泛型类或方法中使用指针类型。这意味着你不能创建一个泛型类或方法来处理通用的指针操作，限制了泛型的灵活
3）函数指针
C# 中有delegate，delegate 支持支持指针类型，lambda 表达式也支持指针。委托是 C# 中一个非常强大的功能，它允许将方法作为参数传递给其他方法，类似于 C 和 C++ 中的函数指针。委托可以引用具有特定参数列表和返回类型的任何方法。C# 提供 delegate 类型来定义安全函数指针对象。