Skip to main content
 首页 » 编程设计

C#创建共享内存,可用于两个独立进程间的通信(转)

2022年07月19日147birdshome

https://www.cnblogs.com/hepeng/p/8780552.html

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;      //写成功
         }
     }

  两个程序进行读和写:

1
2
3
4
5
6
<br>          ShareMem MemDB =  new  ShareMem();<br>          MemDB.Init( "testrom" , 1024 * 1024);
       byte [] bytData =  new  byte [1024 * 1024];
       int  intRet = MemDB.Read( ref  bytData, 0, 1024 * 1024);
       txtAll.Text = Encoding.UTF8.GetString(bytData);
       txtAll.Select(txtAll.TextLength, 0);
       txtAll.ScrollToCaret();

  

1
2
3
MemDB.Init( "testrom" , 1024 * 1024);
byte [] bytData = Encoding.UTF8.GetBytes( string .Join( "\r\n" , allLines));
MemDB.Write(bytData, 0, bytData.Length);

本文参考链接:https://www.cnblogs.com/xihong2014/p/14704735.html