unsafe & fixed

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

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

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

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

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

// compile with: /unsafeusing 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函数实现。