共享内存操作类(C#源码)[转]

VC++的共享内存操作代码实现起来相对比较容易，但是用C#语言来实现，就有一定难度，由于工作需要，把以前VC开发的共享内存代码要用C#实现，别说，还费了不少周折，毕竟C#操作API函数和地址指针不是那么直接，还好，总算完成了，效果还不错。

    

共享内存操作类：    

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Runtime.InteropServices;

namespace  ShareMemLib
{
     public   class  ShareMem
    {
        [DllImport( " user32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern  IntPtr SendMessage(IntPtr hWnd,  int  Msg,  int  wParam, IntPtr lParam);

        [DllImport( " Kernel32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern  IntPtr CreateFileMapping( int  hFile, IntPtr lpAttributes,  uint  flProtect,  uint  dwMaxSizeHi,  uint  dwMaxSizeLow,  string  lpName);
        
        [DllImport( " Kernel32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern  IntPtr OpenFileMapping( int  dwDesiredAccess,[MarshalAs(UnmanagedType.Bool)]  bool  bInheritHandle, string  lpName);

        [DllImport( " Kernel32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern  IntPtr MapViewOfFile(IntPtr hFileMapping, uint  dwDesiredAccess,  uint  dwFileOffsetHigh,  uint  dwFileOffsetLow, uint  dwNumberOfBytesToMap);

        [DllImport( " Kernel32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern   bool  UnmapViewOfFile(IntPtr pvBaseAddress);

        [DllImport( " Kernel32.dll " , CharSet  =  CharSet.Auto)]
         public   static   extern   bool  CloseHandle(IntPtr handle);

        [DllImport( " kernel32 " , EntryPoint = " GetLastError " )]
         public   static   extern   int  GetLastError ();

         const   int  ERROR_ALREADY_EXISTS  =   183 ;

         const   int  FILE_MAP_COPY  =   0x0001 ;
         const   int  FILE_MAP_WRITE  =   0x0002 ;
         const   int  FILE_MAP_READ  =   0x0004 ;
         const   int  FILE_MAP_ALL_ACCESS  =   0x0002   |   0x0004 ;

         const   int  PAGE_READONLY  =   0x02 ;
         const   int  PAGE_READWRITE  =   0x04 ;
         const   int  PAGE_WRITECOPY  =   0x08 ;
         const   int  PAGE_EXECUTE  =   0x10 ;
         const   int  PAGE_EXECUTE_READ  =   0x20 ;
         const   int  PAGE_EXECUTE_READWRITE  =   0x40 ;

         const   int  SEC_COMMIT  =   0x8000000 ;
         const   int  SEC_IMAGE  =   0x1000000 ;
         const   int  SEC_NOCACHE  =   0x10000000 ;
         const   int  SEC_RESERVE  =   0x4000000 ;

         const   int  INVALID_HANDLE_VALUE  =   - 1 ;

        IntPtr m_hSharedMemoryFile  =  IntPtr.Zero;
        IntPtr m_pwData  =  IntPtr.Zero;
         bool  m_bAlreadyExist  =   false ;
         bool  m_bInit  =   false ;
         long  m_MemSize = 0 ;

         public  ShareMem()
        {
        }
         ~ ShareMem()
        {
            Close();
        }

         ///   <summary>
         ///  初始化共享内存
         ///   </summary>
         ///   <param name="strName"> 共享内存名称 </param>
         ///   <param name="lngSize"> 共享内存大小 </param>
         ///   <returns></returns>
         public   int  Init( string  strName,  long  lngSize)
        {
             if  (lngSize  <=   0   ||  lngSize  >   0x00800000 ) lngSize  =   0x00800000 ;
            m_MemSize  =  lngSize;
             if  (strName.Length  >   0 )
            {
                 // 创建内存共享体(INVALID_HANDLE_VALUE)
                m_hSharedMemoryFile  =  CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, ( uint )PAGE_READWRITE,  0 , ( uint )lngSize, strName);
                 if  (m_hSharedMemoryFile  ==  IntPtr.Zero)
                {
                    m_bAlreadyExist  =   false ;
                    m_bInit  =   false ;
                     return   2 ;  // 创建共享体失败
                }
                 else
                {
                     if  (GetLastError()  ==  ERROR_ALREADY_EXISTS)   // 已经创建
                    {
                        m_bAlreadyExist  =   true ;
                    }
                     else                                           // 新创建
                    {
                        m_bAlreadyExist  =   false ;
                    }
                }
                 // ---------------------------------------
                 // 创建内存映射
                m_pwData  =  MapViewOfFile(m_hSharedMemoryFile, FILE_MAP_WRITE,  0 ,  0 , ( uint )lngSize);
                 if  (m_pwData  ==  IntPtr.Zero)
                {
                    m_bInit  =   false ;
                    CloseHandle(m_hSharedMemoryFile);
                     return   3 ;  // 创建内存映射失败
                }
                 else
                {
                    m_bInit  =   true ;
                     if  (m_bAlreadyExist  ==   false )
                    {
                         // 初始化
                    }
                }
                 // ----------------------------------------
            }
             else
            {
                 return   1 ;  // 参数错误     
            }

             return   0 ;      // 创建成功
        }
         ///   <summary>
         ///  关闭共享内存
         ///   </summary>
         public   void  Close()
        {
             if  (m_bInit)
            {
                UnmapViewOfFile(m_pwData);
                CloseHandle(m_hSharedMemoryFile);
            }
        }

         ///   <summary>
         ///  读数据
         ///   </summary>
         ///   <param name="bytData"> 数据 </param>
         ///   <param name="lngAddr"> 起始地址 </param>
         ///   <param name="lngSize"> 个数 </param>
         ///   <returns></returns>
         public   int  Read( ref   byte [] bytData,  int  lngAddr,  int  lngSize)
        {
             if  (lngAddr  +  lngSize  >  m_MemSize)  return   2 ;  // 超出数据区
             if  (m_bInit)
            {               
                Marshal.Copy(m_pwData, bytData, lngAddr, lngSize);
            }
             else
            {
                 return   1 ;  // 共享内存未初始化
            }
             return   0 ;      // 读成功
        }

         ///   <summary>
         ///  写数据
         ///   </summary>
         ///   <param name="bytData"> 数据 </param>
         ///   <param name="lngAddr"> 起始地址 </param>
         ///   <param name="lngSize"> 个数 </param>
         ///   <returns></returns>
         public   int  Write( byte [] bytData,  int  lngAddr,  int  lngSize)
        {
             if  (lngAddr  +  lngSize  >  m_MemSize)  return   2 ;  // 超出数据区
             if  (m_bInit)
            {
                Marshal.Copy(bytData, lngAddr, m_pwData, lngSize);
            }
             else
            {
                 return   1 ;  // 共享内存未初始化
            }
             return   0 ;      // 写成功
        }
    }
}

测试例程： 

using  System;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Text;
using  System.Windows.Forms;
using  ShareMemLib;

namespace  YFShareMem
{
     public   partial   class  frmShareMem : Form
    {
        ShareMem MemDB = new  ShareMem();
         public  frmShareMem()
        {
            InitializeComponent();
        }

         private   void  btnOpen_Click( object  sender, EventArgs e)
        {
             if  (MemDB.Init( " YFMemTest " ,  10240 )  !=   0 )
            {
                 // 初始化失败
                MessageBox.Show( " 初始化失败 " );
            }
             else
            {
                btnOpen.Enabled  =   false ;
                chkWrite.Enabled  =   true ;
                tmrTime.Enabled  =   true ;
            }
        }

         private   void  tmrTime_Tick( object  sender, EventArgs e)
        {
             byte [] bytData  =   new   byte [ 16 ];
             int  intRet  =  MemDB.Read( ref  bytData,  0 ,  16 );
            lstData.Items.Clear(); 
             if  (intRet  ==   0 )
            {
                 for  ( int  i  =   0 ; i  <   16 ; i ++ )
                {
                    lstData.Items.Add(bytData[i].ToString());
                }

                 if  (chkWrite.Checked)
                {
                    bytData[ 0 ] ++ ;
                    bytData[ 1 ]  +=   2 ;
                     if  (bytData[ 0 ]  >   200 ) bytData[ 0 ]  =   0 ;
                     if  (bytData[ 1 ]  >   200 ) bytData[ 1 ]  =   0 ;
                    MemDB.Write(bytData,  0 ,  16 );
                }
            }           
        }

    }
}

全文】

首先还是定义非托管调用，如下：

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 ();