unsafe & fixed

unsafe 关键字表示不安全上下文，该上下文是任何涉及指针的操作所必需的

请注意使用了 unsafe 关键字，这允许在 Copy 方法内使用指针。
fixed 语句用于声明指向源和目标数组的指针。它锁定 src 和 dst 对象在内存中的位置以便使其不会被垃圾回收移动。当 fixed 块完成后，这些对象将被解除锁定。
通过略过数组界限检查，不安全代码 可提高性能。

fixed 语句允许您获取指向字节数组使用的内存的指针，并且标记实例，以便垃圾回收器不会移动它。

在 fixed 块的末尾，将标记该实例以便可以移动它。此功能称为声明式锁定。锁定的好处是系统开销非常小，除非在 fixed 块中发生垃圾回收（但此情况不太可能发生）。

对头，fixed 内我只分配我自己的内存，用完就释放，从不霸占平民土地，不多征收平民余粮！！
对于如果你要是等着GC来跟你处理，它寻根寻址还得点时候 呢。。。。。

// compile with: /unsafe using System; class Test {     // The unsafe keyword allows pointers to be used within     // the following method:     static unsafe void Copy(byte[] src, int srcIndex,         byte[] dst, int dstIndex, int count)     {         if (src == null || srcIndex < 0 ||             dst == null || dstIndex < 0 || count < 0)         {             throw new ArgumentException();         }         int srcLen = src.Length;         int dstLen = dst.Length;         if (srcLen - srcIndex < count ||             dstLen - dstIndex < count)         {             throw new ArgumentException();         }             // The following fixed statement pins the location of             // the src and dst objects in memory so that they will             // not be moved by garbage collection.                    fixed (byte* pSrc = src, pDst = dst)             {                   byte* ps = pSrc;                   byte* pd = pDst;             // Loop over the count in blocks of 4 bytes, copying an             // integer (4 bytes) at a time:             for (int n =0 ; n < count/4 ; n++)             {                 *((int*)pd) = *((int*)ps);                 pd += 4;                 ps += 4;             }             // Complete the copy by moving any bytes that weren’t             // moved in blocks of 4:             for (int n =0; n < count%4; n++)             {                 *pd = *ps;                 pd++;                 ps++;             }             }     }     static void Main(string[] args)     {         byte[] a = new byte[100];         byte[] b = new byte[100];         for(int i=0; i<100; ++i)           a = (byte)i;         Copy(a, 0, b, 0, 100);         Console.WriteLine(”The first 10 elements are:”);         for(int i=0; i<10; ++i)           Console.Write(b + ” “);         Console.WriteLine(”/n”);     } }

 

Sample 2,共享内存的使用

const int INVALID_HANDLE_VALUE = -1; const int PAGE_READWRITE = 0x04; //共享内存 [DllImport("Kernel32.dll",EntryPoint="CreateFileMapping")] private static extern IntPtr CreateFileMapping(IntPtr hFile, //HANDLE hFile, UInt32 lpAttributes,//LPSECURITY_ATTRIBUTES lpAttributes, //0 UInt32 flProtect,//DWORD flProtect UInt32 dwMaximumSizeHigh,//DWORD dwMaximumSizeHigh, UInt32 dwMaximumSizeLow,//DWORD dwMaximumSizeLow, string lpName//LPCTSTR lpName ); [DllImport("Kernel32.dll",EntryPoint="OpenFileMapping")] private static extern IntPtr OpenFileMapping( UInt32 dwDesiredAccess,//DWORD dwDesiredAccess, int bInheritHandle,//BOOL bInheritHandle, string lpName//LPCTSTR lpName ); const int FILE_MAP_ALL_ACCESS = 0x0002; const int FILE_MAP_WRITE = 0x0002; [DllImport("Kernel32.dll",EntryPoint="MapViewOfFile")] private static extern IntPtr MapViewOfFile( IntPtr hFileMappingObject,//HANDLE hFileMappingObject, UInt32 dwDesiredAccess,//DWORD dwDesiredAccess UInt32 dwFileOffsetHight,//DWORD dwFileOffsetHigh, UInt32 dwFileOffsetLow,//DWORD dwFileOffsetLow, UInt32 dwNumberOfBytesToMap//SIZE_T dwNumberOfBytesToMap ); [DllImport("Kernel32.dll",EntryPoint="UnmapViewOfFile")] private static extern int UnmapViewOfFile(IntPtr lpBaseAddress); [DllImport("Kernel32.dll",EntryPoint="CloseHandle")] private static extern int CloseHandle(IntPtr hObject); 然后分别在AB两个进程中定义如下两个信号量及相关变量； private Semaphore m_Write; //可写的信号 private Semaphore m_Read; //可读的信号 private IntPtr handle; //文件句柄 private IntPtr addr; //共享内存地址 uint mapLength; //共享内存长 定义这两个信号量是为读写互斥用的。 在A进程中创建共享内存： m_Write = new Semaphore(1,1,"WriteMap"); m_Read = new Semaphore(0,1,"ReadMap"); mapLength = 1024; IntPtr hFile = new IntPtr(INVALID_HANDLE_VALUE); handle = CreateFileMapping(hFile,0,PAGE_READWRITE,0,mapLength,"shareMemory"); addr = MapViewOfFile(handle,FILE_MAP_ALL_ACCESS,0,0,0); 然后再向共享内存中写入数据： m_Write.WaitOne(); byte[] sendStr = Encoding.Default.GetBytes(txtMsg.Text + '/0'); //如果要是超长的话，应另外处理，最好是分配足够的内存 if(sendStr.Length < mapLength) Copy(sendStr,addr); m_Read.Release(); 这是在一个单独的方法中实现的，可多次调用，但受信号量的控制。其中txtMsg是一个文本框控件，实际中可用任意字符串，加最后的'/0'是为了让在共享内存中的字符串有一个结束符，否则在内存中取出时是以'/0'为准的，就会出现取多的情况。 Copy方法的实现如下： static unsafe void Copy(byte[] byteSrc,IntPtr dst) { fixed (byte* pSrc = byteSrc) { byte* pDst = (byte*)dst; byte* psrc = pSrc; for(int i=0;i<byteSrc.Length;i++) { *pDst = *psrc; pDst++; psrc ++; } } } 注意unsafe 关键字，在编译时一定要打开非安全代码开关。 最后不要忘了在A进程中关闭共享内存对象，以免内存泄露。 UnmapViewOfFile(addr); CloseHandle(handle); 要在B进程中读取共享内存中的数据，首先要打开共享内存对象： m_Write = Semaphore.OpenExisting("WriteMap"); m_Read = Semaphore.OpenExisting("ReadMap"); handle = OpenFileMapping(0x0002,0,"shareMemory"); 读取共享内存中的数据： m_Read.WaitOne(); string str = MapViewOfFile(handle,FILE_MAP_ALL_ACCESS,0,0,0); txtMsg.Text = str; m_Write.Release(); 这里获取了字符串，如果要获取byte数组，请参考上面的Copy函数实现。