c#读写共享内存操作函数封装

2022-10-03 13:02:10

原文 c#读写共享内存操作函数封装

c#共享内存操作相对c++共享内存操作来说原理是一样，但是c#会显得有点复杂。

现把昨天封装的读写共享内存封装的函数记录下来，一方面希望给需要这块的有点帮助，另一方面则是做个备份吧。

[csharp] view plaincopy
  1. /// <summary>
  2. /// 写共享内存
  3. /// </summary>
  4. /// <param name="structSize">需要映射的文件的字节数量</param>
  5. /// <param name="obj">映射对象（简单类型、结构体等）</param>
  6. /// <param name="fileName">文件映射对象的名称</param>
  7. /// <param name="windowName">发送消息的窗口句柄</param>
  8. /// <param name="Msg">发送消息</param>
  9. /// <returns></returns>
  10. public static int WriteToMemory(uint structSize, Object obj, string fileName, string windowName, uint Msg)
  11. {
  12. IntPtr hShareMemoryHandle = IntPtr.Zero;
  13. IntPtr hVoid = IntPtr.Zero;
  14. //判断参数的合法性
  15. if (structSize > 0 && fileName.Length > 0)
  16. {
  17. hShareMemoryHandle = CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, (uint)PAGE_READWRITE, 0, (uint)structSize, fileName);
  18. if (hShareMemoryHandle == IntPtr.Zero)
  19. {
  20. //创建共享内存失败，记log
  21. MessageBox.Show("创建共享内存失败"+publicInfo.GetLastError().ToString());
  22. return -2;
  23. }
  24. else
  25. {
  26. if (ERROR_ALREADY_EXISTS == GetLastError())
  27. {
  28. //共享内存已经存在，记log
  29. MessageBox.Show("共享内存已经存在");
  30. return -3;
  31. }
  32. }
  33. hVoid = MapViewOfFile(hShareMemoryHandle, FILE_MAP_WRITE, 0, 0, structSize);
  34. if (hVoid == IntPtr.Zero)
  35. {
  36. CloseHandle(hShareMemoryHandle);
  37. //文件映射失败，记log
  38. MessageBox.Show("文件映射失败");
  39. return -4;
  40. }
  41. Marshal.StructureToPtr(obj, hVoid, false);
  42. //发送消息，通知接收
  43. IntPtr handle = FindWindow(null, windowName.Trim());
  44. if (handle == IntPtr.Zero)
  45. {
  46. //查找窗口失败，记log
  47. MessageBox.Show("查找窗口失败");
  48. return -5;
  49. }
  50. else
  51. {
  52. if (PostMessage(handle, (uint)Msg, 0, 0))
  53. {
  54. //发送消息成功
  55. //MessageBox.Show("写共享内存，通知发送消息成功");
  56. }
  57. }
  58. }
  59. else
  60. {
  61. //参数不合法，记log
  62. MessageBox.Show("共享内存已经存在");
  63. return -1;
  64. }
  65. return 0;
  66. }

写共享内存函数并没有什么需要说明，完全按照：

创建共享内存文件(CreateFileMapping)---》映射文件视图到调用进程的地址空间（MapViewOfFile）---》写数据到共享内存(Marshal.StructureToPtr)----》发送消息通知需要读共享内存的窗口（PostMessage）

[csharp] view plaincopy
  1. /// <summary>
  2. /// 读共享内存
  3. /// </summary>
  4. /// <param name="structSize">需要映射的文件的字节数量</param>
  5. /// <param name="type">类型</param>
  6. /// <param name="fileName">文件映射对象的名称</param>
  7. /// <returns>返回读到的映射对象</returns>
  8. public static Object ReadFromMemory(uint structSize, Type type, string fileName)
  9. {
  10. IntPtr hMappingHandle = IntPtr.Zero;
  11. IntPtr hVoid = IntPtr.Zero;
  12. hMappingHandle = OpenFileMapping((uint)FILE_MAP_READ, false, fileName);
  13. if (hMappingHandle == IntPtr.Zero)
  14. {
  15. //打开共享内存失败，记log
  16. MessageBox.Show("打开共享内存失败:" + publicInfo.GetLastError().ToString());
  17. return null;
  18. }
  19. hVoid = MapViewOfFile(hMappingHandle, FILE_MAP_READ, 0, 0, structSize);
  20. if (hVoid == IntPtr.Zero)
  21. {
  22. //文件映射失败，记log
  23. MessageBox.Show("文件映射失败——读共享内存");
  24. return null;
  25. }
  26. Object obj = Marshal.PtrToStructure(hVoid, type);
  27. if (hVoid != IntPtr.Zero)
  28. {
  29. UnmapViewOfFile(hVoid);
  30. hVoid = IntPtr.Zero;
  31. }
  32. if (hMappingHandle != IntPtr.Zero)
  33. {
  34. CloseHandle(hMappingHandle);
  35. hMappingHandle = IntPtr.Zero;
  36. }
  37. return obj;
  38. }

读共享内存，上边代码是一种方式，这里是传入一个Type类型，这样就确保可以传入任何类型。当读到共享内存的数据时，采用

public static object PtrToStructure(IntPtr ptr, Type structureType);

函数，把非托管指针（共享内存获得的指针）转换为需要转换的Type类型的对象。如果需要的话，可以通过显示类型转换转换为需要的类型（例子继续看）。

[csharp] view plaincopy
  1. /// <summary>
  2. /// 读共享内存
  3. /// </summary>
  4. /// <param name="structSize">需要映射的文件的字节数量</param>
  5. /// <param name="type">类型</param>
  6. /// <param name="fileName">文件映射对象的名称</param>
  7. /// <returns>返回读到的映射字节数据</returns>
  8. public static byte[] ReadFromMemory(uint structSize, Type type, string fileName)
  9. {
  10. IntPtr hMappingHandle = IntPtr.Zero;
  11. IntPtr hVoid = IntPtr.Zero;
  12. hMappingHandle = OpenFileMapping((uint)FILE_MAP_READ, false, fileName);
  13. if (hMappingHandle == IntPtr.Zero)
  14. {
  15. //打开共享内存失败，记log
  16. MessageBox.Show("打开共享内存失败:" + publicInfo.GetLastError().ToString());
  17. return null;
  18. }
  19. hVoid = MapViewOfFile(hMappingHandle, FILE_MAP_READ, 0, 0, structSize);
  20. if (hVoid == IntPtr.Zero)
  21. {
  22. //文件映射失败，记log
  23. MessageBox.Show("文件映射失败——读共享内存");
  24. return null;
  25. }
  26. //Object obj = Marshal.PtrToStructure(hVoid, type);
  27. byte[] bytes = new byte[structSize];
  28. Marshal.Copy(hVoid, bytes, 0, bytes.Length);
  29. if (hVoid != IntPtr.Zero)
  30. {
  31. UnmapViewOfFile(hVoid);
  32. hVoid = IntPtr.Zero;
  33. }
  34. if (hMappingHandle != IntPtr.Zero)
  35. {
  36. CloseHandle(hMappingHandle);
  37. hMappingHandle = IntPtr.Zero;
  38. }
  39. return bytes;
  40. }

此代码和第一个读共享内存不同的是，采用byte[]读需要的共享内存。使用托管类中的Copy来转换指针。

[csharp] view plaincopy
  1. byte[] bytes = new byte[structSize];
  2. arshal.Copy(hVoid, bytes, 0, bytes.Length);

调用简单例子部分代码如下：

注：passiveInfo是NotifyInfo结构体对象。

写共享内存：

[csharp] view plaincopy
  1. int iRet = publicInfo.WriteToMemory((uint)Marshal.SizeOf(passiveInfo),(Object)passiveInfo, "memName","FormMsg",(uint)publicInfo.WM_NOTIFY);

读共享内存：

第一种情况调用：

[csharp] view plaincopy
  1. passiveInfo = (NotifyPassiveInfo)publicInfo.ReadFromMemory((uint)Marshal.SizeOf(passiveInfo), typeof(NotifyPassiveInfo), publicInfo.SN_PASSIVEINFO);

第二种情况调用：

[csharp] view plaincopy
  1. byte[] bytes = publicInfo.ReadFromMemory((uint)Marshal.SizeOf(passiveInfo), "memName");
  2. passiveInfo = (NotifyInfo)BytesToStuct(bytes, typeof(NotifyInfo));

希望对你有帮助。

转载请标注：http://blog.csdn.net/richerg85

上一篇：ulimit 说明


下一篇：spring拦截器中使用spring的自动注入