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

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

    

共享内存操作类:    

 
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Runtime.InteropServices;  
  5.  
  6. namespace ShareMemLib  
  7. {  
  8.     public class ShareMem  
  9.     {  
  10.         [DllImport("user32.dll", CharSet = CharSet.Auto)]  
  11.         public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, int wParam, IntPtr lParam);  
  12.  
  13.         [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]  
  14.         public static extern IntPtr CreateFileMapping(int hFile, IntPtr lpAttributes, uint flProtect, uint dwMaxSizeHi, uint dwMaxSizeLow, string lpName);  
  15.           
  16.         [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]  
  17.         public static extern IntPtr OpenFileMapping(int dwDesiredAccess,[MarshalAs(UnmanagedType.Bool)] bool bInheritHandle,string lpName);  
  18.  
  19.         [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]  
  20.         public static extern IntPtr MapViewOfFile(IntPtr hFileMapping,uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow,uint dwNumberOfBytesToMap);  
  21.  
  22.         [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]  
  23.         public static extern bool UnmapViewOfFile(IntPtr pvBaseAddress);  
  24.  
  25.         [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]  
  26.         public static extern bool CloseHandle(IntPtr handle);  
  27.  
  28.         [DllImport("kernel32", EntryPoint="GetLastError")]  
  29.         public static extern int GetLastError ();  
  30.  
  31.         const int ERROR_ALREADY_EXISTS = 183;  
  32.  
  33.         const int FILE_MAP_COPY = 0x0001;  
  34.         const int FILE_MAP_WRITE = 0x0002;  
  35.         const int FILE_MAP_READ = 0x0004;  
  36.         const int FILE_MAP_ALL_ACCESS = 0x0002 | 0x0004;  
  37.  
  38.         const int PAGE_READONLY = 0x02;  
  39.         const int PAGE_READWRITE = 0x04;  
  40.         const int PAGE_WRITECOPY = 0x08;  
  41.         const int PAGE_EXECUTE = 0x10;  
  42.         const int PAGE_EXECUTE_READ = 0x20;  
  43.         const int PAGE_EXECUTE_READWRITE = 0x40;  
  44.  
  45.         const int SEC_COMMIT = 0x8000000;  
  46.         const int SEC_IMAGE = 0x1000000;  
  47.         const int SEC_NOCACHE = 0x10000000;  
  48.         const int SEC_RESERVE = 0x4000000;  
  49.  
  50.         const int INVALID_HANDLE_VALUE = -1;  
  51.  
  52.         IntPtr m_hSharedMemoryFile = IntPtr.Zero;  
  53.         IntPtr m_pwData = IntPtr.Zero;  
  54.         bool m_bAlreadyExist = false;  
  55.         bool m_bInit = false;  
  56.         long m_MemSize=0;  
  57.  
  58.         public ShareMem()  
  59.         {  
  60.         }  
  61.         ~ShareMem()  
  62.         {  
  63.             Close();  
  64.         }  
  65.  
  66.         /// <summary>  
  67.         /// 初始化共享内存  
  68.         /// </summary>  
  69.         /// <param name="strName">共享内存名称</param>  
  70.         /// <param name="lngSize">共享内存大小</param>  
  71.         /// <returns></returns>  
  72.         public int Init(string strName, long lngSize)  
  73.         {  
  74.             if (lngSize <= 0 || lngSize > 0x00800000) lngSize = 0x00800000;  
  75.             m_MemSize = lngSize;  
  76.             if (strName.Length > 0)  
  77.             {  
  78.                 //创建内存共享体(INVALID_HANDLE_VALUE)  
  79.                 m_hSharedMemoryFile = CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, (uint)PAGE_READWRITE, 0, (uint)lngSize, strName);  
  80.                 if (m_hSharedMemoryFile == IntPtr.Zero)  
  81.                 {  
  82.                     m_bAlreadyExist = false;  
  83.                     m_bInit = false;  
  84.                     return 2; //创建共享体失败  
  85.                 }  
  86.                 else 
  87.                 {  
  88.                     if (GetLastError() == ERROR_ALREADY_EXISTS)  //已经创建  
  89.                     {  
  90.                         m_bAlreadyExist = true;  
  91.                     }  
  92.                     else                                         //新创建  
  93.                     {  
  94.                         m_bAlreadyExist = false;  
  95.                     }  
  96.                 }  
  97.                 //---------------------------------------  
  98.                 //创建内存映射  
  99.                 m_pwData = MapViewOfFile(m_hSharedMemoryFile, FILE_MAP_WRITE, 0, 0, (uint)lngSize);  
  100.                 if (m_pwData == IntPtr.Zero)  
  101.                 {  
  102.                     m_bInit = false;  
  103.                     CloseHandle(m_hSharedMemoryFile);  
  104.                     return 3; //创建内存映射失败  
  105.                 }  
  106.                 else 
  107.                 {  
  108.                     m_bInit = true;  
  109.                     if (m_bAlreadyExist == false)  
  110.                     {  
  111.                         //初始化  
  112.                     }  
  113.                 }  
  114.                 //----------------------------------------  
  115.             }  
  116.             else 
  117.             {  
  118.                 return 1; //参数错误       
  119.             }  
  120.  
  121.             return 0;     //创建成功  
  122.         }  
  123.         /// <summary>  
  124.         /// 关闭共享内存  
  125.         /// </summary>  
  126.         public void Close()  
  127.         {  
  128.             if (m_bInit)  
  129.             {  
  130.                 UnmapViewOfFile(m_pwData);  
  131.                 CloseHandle(m_hSharedMemoryFile);  
  132.             }  
  133.         }  
  134.  
  135.         /// <summary>  
  136.         /// 读数据  
  137.         /// </summary>  
  138.         /// <param name="bytData">数据</param>  
  139.         /// <param name="lngAddr">起始地址</param>  
  140.         /// <param name="lngSize">个数</param>  
  141.         /// <returns></returns>  
  142.         public int Read(ref byte[] bytData, int lngAddr, int lngSize)  
  143.         {  
  144.             if (lngAddr + lngSize > m_MemSize) return 2; //超出数据区  
  145.             if (m_bInit)  
  146.             {                 
  147.                 Marshal.Copy(m_pwData, bytData, lngAddr, lngSize);  
  148.             }  
  149.             else 
  150.             {  
  151.                 return 1; //共享内存未初始化  
  152.             }  
  153.             return 0;     //读成功  
  154.         }  
  155.  
  156.         /// <summary>  
  157.         /// 写数据  
  158.         /// </summary>  
  159.         /// <param name="bytData">数据</param>  
  160.         /// <param name="lngAddr">起始地址</param>  
  161.         /// <param name="lngSize">个数</param>  
  162.         /// <returns></returns>  
  163.         public int Write(byte[] bytData, int lngAddr, int lngSize)  
  164.         {  
  165.             if (lngAddr + lngSize > m_MemSize) return 2; //超出数据区  
  166.             if (m_bInit)  
  167.             {  
  168.                 Marshal.Copy(bytData, lngAddr, m_pwData, lngSize);  
  169.             }  
  170.             else 
  171.             {  
  172.                 return 1; //共享内存未初始化  
  173.             }  
  174.             return 0;     //写成功  
  175.         }  
  176.     }  
  177. }  
  178.  
  179. 测试例程:   
  180.  
  181. using System;  
  182. using System.Collections.Generic;  
  183. using System.ComponentModel;  
  184. using System.Data;  
  185. using System.Drawing;  
  186. using System.Text;  
  187. using System.Windows.Forms;  
  188. using ShareMemLib;  
  189.  
  190. namespace YFShareMem  
  191. {  
  192.     public partial class frmShareMem : Form  
  193.     {  
  194.         ShareMem MemDB=new ShareMem();  
  195.         public frmShareMem()  
  196.         {  
  197.             InitializeComponent();  
  198.         }  
  199.  
  200.         private void btnOpen_Click(object sender, EventArgs e)  
  201.         {  
  202.             if (MemDB.Init("YFMemTest", 10240) != 0)  
  203.             {  
  204.                 //初始化失败  
  205.                 MessageBox.Show("初始化失败");  
  206.             }  
  207.             else 
  208.             {  
  209.                 btnOpen.Enabled = false;  
  210.                 chkWrite.Enabled = true;  
  211.                 tmrTime.Enabled = true;  
  212.             }  
  213.         }  
  214.  
  215.         private void tmrTime_Tick(object sender, EventArgs e)  
  216.         {  
  217.             byte[] bytData = new byte[16];  
  218.             int intRet = MemDB.Read(ref bytData, 0, 16);  
  219.             lstData.Items.Clear();   
  220.             if (intRet == 0)  
  221.             {  
  222.                 for (int i = 0; i < 16; i++)  
  223.                 {  
  224.                     lstData.Items.Add(bytData[i].ToString());  
  225.                 }  
  226.  
  227.                 if (chkWrite.Checked)  
  228.                 {  
  229.                     bytData[0]++;  
  230.                     bytData[1] += 2;  
  231.                     if (bytData[0] > 200) bytData[0] = 0;  
  232.                     if (bytData[1] > 200) bytData[1] = 0;  
  233.                     MemDB.Write(bytData, 0, 16);  
  234.                 }  
  235.             }             
  236.         }  
  237.  
  238.     }  
  239. }  
  240.  

 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值