devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

通过进程协作显示图像-C#

作者：weixin_40725706 | 2024-08-05 06:29:35

赞

踩

通过进程协作显示图像-C#

前言

如果一个软件比较复杂或者某些情况下需要拆解，可以考试将软件分解成两个或多个进程，但常规的消息传递又不能完全够用，使用消息+共享内存，实现图像传递，当然性能这个方面我并没有测试，仅是一种解决思路吧。

一、效果展示

1、调用方

2、被调用方

二、实现代码

1、主调打开调用进程

主要是为了拿到Handle，为发送消息函数提供操作句柄。

2、创建共享内存

  1.         /// <summary>
  2.         /// 创建共享内存
  3.         /// </summary>
  4.         /// <returns>0=创建成功;1=创建共享体失败;2=打开失败;3=印射失败; 4=共享内存命名错误</returns>
  5.         public int CreateMemory()
  6.         {
  7.             if (MemSize <= 0) MemSize = 0x00800000;
  8.             if (ShareName.Length > 0)
  9.             {
  10.                 //创建内存共享体(INVALID_HANDLE_VALUE)
  11.                 m_hSharedMemoryFile = CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, (uint)PAGE_READWRITE, 0, (uint)MemSize, ShareName);
  12.                 if (m_hSharedMemoryFile == IntPtr.Zero)
  13.                 {
  14.                     m_bAlreadyExist = false;
  15.                     m_bInit = false;
  16.                     MemPtr = IntPtr.Zero;
  17.                     return 1; //创建共享体失败
  18.                 }
  19.                 else
  20.                 {
  21.                     if (GetLastError() == ERROR_ALREADY_EXISTS) //已经创建
  22.                     {
  23.                         m_bAlreadyExist = true;
  24.                         CloseHandle(m_hSharedMemoryFile);
  25.                         m_hSharedMemoryFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, ShareName);
  26.                         if (m_hSharedMemoryFile == null)
  27.                         {
  28.                             MemPtr = IntPtr.Zero;
  29.                             return 2;//打开共享内存失败
  30.                         }
  31.                     }
  32.                     else                                         //新创建
  33.                     {
  34.                         m_bAlreadyExist = false;
  35.                     }
  36.                 }
  37.                 //创建内存映射
  38.                 m_rwData = MapViewOfFile(m_hSharedMemoryFile, FILE_MAP_ALL_ACCESS, 0, 0, (uint)MemSize);
  39.                 if (m_rwData == IntPtr.Zero)
  40.                 {
  41.                     m_bInit = false;
  42.                     CloseHandle(m_hSharedMemoryFile);
  43.                     MemPtr = IntPtr.Zero;
  44.                     return 3; //创建内存映射失败
  45.                 }
  46.                 else
  47.                 {
  48.                     m_bInit = true;
  49.                     MemPtr = m_rwData;
  50.                 }
  51.             }
  52.             else
  53.             {
  54.                 return 4; //参数错误
  55.             }
  56.             return 0;     //创建成功
  57.         }

3、读取本地图像并写图像数据到共享内存中

  1.  MyAlgoProcessNet.HImage hImage = new MyAlgoProcessNet.HImage(fileName);
  2.  
  3.  IntPtr prt = hImage.GetImagePointer1(out string type, out imageData.Widht, out imageData.Height);
  4.  imageData.dataLength = imageData.Widht * imageData.Height;
  5.  byte[] datas = new byte[imageData.dataLength];
  6.  Marshal.Copy(prt, datas, 0, imageData.dataLength);
  7.  int pos = Marshal.SizeOf(imageData);
  8.  share1.WriteToMemory(imageData);
  9.  
  10.  //写共享内存
  11.  if (share1.WriteBytes(datas, pos + 1) == 0)
  12.  {
  13.      WriteMsg("share1写入共享内存成功");
  14.  }
  15.  else
  16.  {
  17.      WriteMsg("share1写入共享内存失败！！");
  18.  }
  19.  
  20.  
  21.  
  22.    public int WriteBytes(byte[] datas, int pos = -1)
  23.    {
  24.        if (IntPtr.Zero == MemPtr)
  25.        {
  26.            return -1;
  27.        }
  28.        if (pos == -1)
  29.        {
  30.            Marshal.Copy(datas, 0, MemPtr, datas.Length);
  31.        }
  32.        else
  33.        {
  34.            IntPtr offPtr = IntPtr.Add(MemPtr, pos);
  35.            Marshal.Copy(datas, 0, offPtr, datas.Length);
  36.        }
  37.  
  38.        return 0;
  39.    }

4、通知读取数据

  1. private void SendMsg2(string msg)
  2. {
  3.     // 获取目标进程句柄
  4.  
  5.     IntPtr hWnd = process.MainWindowHandle;
  6.  
  7.     // 封装消息
  8.  
  9.     byte[] sarr = System.Text.Encoding.Default.GetBytes(msg);
  10.  
  11.     int len = sarr.Length;
  12.  
  13.     COPYDATASTRUCT cds2;
  14.  
  15.     cds2.dwData = (IntPtr)0;
  16.  
  17.     cds2.cbData = len + 1;
  18.  
  19.     cds2.lpData = msg;
  20.  
  21.     // 发送消息
  22.     WriteMsg(msg + " Start");
  23.     SendMessage(hWnd, WM_COPYDATA, IntPtr.Zero, ref cds2);
  24.     WriteMsg(msg + " End");
  25. }

5、被调用方关联消息处理函数

  1.         protected override void OnSourceInitialized(EventArgs e)
  2.         {
  3.             base.OnSourceInitialized(e);
  4.             HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;
  5.             if (hwndSource != null)
  6.             {
  7.                 IntPtr handle = hwndSource.Handle;
  8.                 hwndSource.AddHook(new HwndSourceHook(WndProc));
  9.             }
  10.         }

6、被调用方处理图像数据

  1.         private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
  2.         {
  3.             if (msg == WM_COPYDATA)
  4.             {
  5.                 WriteInfo(1, "WndProc Start");
  6.                 COPYDATASTRUCT cds = (COPYDATASTRUCT)Marshal.PtrToStructure(lParam,
  7.                 typeof(COPYDATASTRUCT)); // 接收封装的消息
  8.                 string rece = cds.lpData; // 获取消息内容
  9.                                           // 自定义行为
  10.                                           //  Console.WriteLine(rece);
  11.  
  12.                 if (rece == "Read")
  13.                 {
  14.                     Task.Run(() =>
  15.                     {
  16.                         //读共享内存
  17.                         // datastruct = (MemoryClass)shareMemory.ReadFromMemory(typeof(MemoryClass));
  18.                         // WriteInfo(1, $"读取数据：{datastruct.bianliang1},{datastruct.bianliang2},{datastruct.bianliang3}");
  19.  
  20.                         imageData = (ImageData)shareMemory.ReadFromMemory(typeof(ImageData));
  21.  
  22.                         int ShareSize = Marshal.SizeOf(imageData);
  23.                         byte[] datas = shareMemory.ReadByteFromMemory(imageData.dataLength, ShareSize + 1);
  24.                         HImage hImage = new HImage();
  25.                         using (PinnedObject pinnedObject = new PinnedObject(datas))
  26.                         {
  27.                             hImage.GenImage1("byte", imageData.Widht, imageData.Height, pinnedObject.Pointer);
  28.                         }
  29.                         // hImage.GenImage1(imageData.DataType, imageData.Widht, imageData.Height, imageData.dataPrt);
  30.                         ImgControl.HalconWindow.AttachBackgroundToWindow(hImage);
  31.                         WriteInfo(1, "图像处理完成");
  32.                     });
  33.                 }
  34.                 // Thread.Sleep(2000);
  35.                 WriteInfo(2, rece);
  36.                 if (rece.Equals("Close"))
  37.                 {
  38.                     this.Close();
  39.                 }
  40.             }
  41.             return hwnd;
  42.         }

7、共享内存操作

  1.   internal class ShareMemory
  2.   {
  3.       [DllImport("user32.dll", CharSet = CharSet.Auto)]
  4.       public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, int wParam, IntPtr lParam);
  5.  
  6.       [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
  7.       public static extern IntPtr CreateFileMapping(int hFile, IntPtr lpAttributes, uint flProtect, uint dwMaxSizeHi, uint dwMaxSizeLow, string lpName);
  8.  
  9.       [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
  10.       public static extern IntPtr OpenFileMapping(int dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, string lpName);
  11.  
  12.       [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
  13.       public static extern IntPtr MapViewOfFile(IntPtr hFileMapping, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, uint dwNumberOfBytesToMap);
  14.  
  15.       [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
  16.       public static extern bool UnmapViewOfFile(IntPtr pvBaseAddress);
  17.  
  18.       [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
  19.       public static extern bool CloseHandle(IntPtr handle);
  20.  
  21.       [DllImport("kernel32", EntryPoint = "GetLastError")]
  22.       public static extern int GetLastError();
  23.  
  24.       private const int INVALID_HANDLE_VALUE = -1;
  25.       private const int ERROR_ALREADY_EXISTS = 0xB7;//183
  26.       private const int PAGE_READWRITE = 0x04;
  27.       private const int FILE_MAP_ALL_ACCESS = 0x0002 | 0x0004;
  28.       private const int FILE_MAP_READ = 0x0004;
  29.       private const int FILE_MAP_WRITE = 0x0002;
  30.  
  31.       private IntPtr m_hSharedMemoryFile = IntPtr.Zero;
  32.       private IntPtr m_rwData = IntPtr.Zero;
  33.       private bool m_bAlreadyExist = false;
  34.       private bool m_bInit = false;
  35.  
  36.       private string ShareName { get; set; } //共享内存的名字
  37.       private long MemSize { get; set; }//共享内存大小
  38.       private IntPtr MemPtr { get; set; }//共享内存印射地址
  39.  
  40.       /// <summary>
  41.       /// 共享内存初始化
  42.       /// </summary>
  43.       /// <param name="MemName">共享内存名字</param>
  44.       /// <param name="MemSize">共享内存大小</param>
  45.       public ShareMemory(string MemName, long Size)
  46.       {
  47.           ShareName = MemName;
  48.           MemSize = Size;
  49.           MemPtr = IntPtr.Zero;
  50.           m_bInit = false;
  51.           m_bAlreadyExist = false;
  52.           m_rwData = IntPtr.Zero;
  53.           m_hSharedMemoryFile = IntPtr.Zero;
  54.       }
  55.  
  56.       ~ShareMemory()
  57.       {
  58.           ShareMemoryClose();
  59.       }
  60.  
  61.       /// <summary>
  62.       /// 创建共享内存
  63.       /// </summary>
  64.       /// <returns>0=创建成功;1=创建共享体失败;2=打开失败;3=印射失败; 4=共享内存命名错误</returns>
  65.       public int CreateMemory()
  66.       {
  67.           if (MemSize <= 0) MemSize = 0x00800000;
  68.           if (ShareName.Length > 0)
  69.           {
  70.               //创建内存共享体(INVALID_HANDLE_VALUE)
  71.               m_hSharedMemoryFile = CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, (uint)PAGE_READWRITE, 0, (uint)MemSize, ShareName);
  72.               if (m_hSharedMemoryFile == IntPtr.Zero)
  73.               {
  74.                   m_bAlreadyExist = false;
  75.                   m_bInit = false;
  76.                   MemPtr = IntPtr.Zero;
  77.                   return 1; //创建共享体失败
  78.               }
  79.               else
  80.               {
  81.                   if (GetLastError() == ERROR_ALREADY_EXISTS) //已经创建
  82.                   {
  83.                       m_bAlreadyExist = true;
  84.                       CloseHandle(m_hSharedMemoryFile);
  85.                       m_hSharedMemoryFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, ShareName);
  86.                       if (m_hSharedMemoryFile == null)
  87.                       {
  88.                           MemPtr = IntPtr.Zero;
  89.                           return 2;//打开共享内存失败
  90.                       }
  91.                   }
  92.                   else                                         //新创建
  93.                   {
  94.                       m_bAlreadyExist = false;
  95.                   }
  96.               }
  97.               //创建内存映射
  98.               m_rwData = MapViewOfFile(m_hSharedMemoryFile, FILE_MAP_ALL_ACCESS, 0, 0, (uint)MemSize);
  99.               if (m_rwData == IntPtr.Zero)
  100.               {
  101.                   m_bInit = false;
  102.                   CloseHandle(m_hSharedMemoryFile);
  103.                   MemPtr = IntPtr.Zero;
  104.                   return 3; //创建内存映射失败
  105.               }
  106.               else
  107.               {
  108.                   m_bInit = true;
  109.                   MemPtr = m_rwData;
  110.               }
  111.           }
  112.           else
  113.           {
  114.               return 4; //参数错误
  115.           }
  116.           return 0;     //创建成功
  117.       }
  118.  
  119.       public byte[] ReadByteFromMemory(int dataLength, int pos = -1)
  120.       {
  121.           if (IntPtr.Zero == MemPtr)
  122.           {
  123.               return new byte[0];
  124.           }
  125.           byte[] datas = new byte[dataLength];
  126.           if (pos == -1)
  127.           {
  128.               Marshal.Copy(MemPtr, datas, 0, dataLength);
  129.           }
  130.           else
  131.           {
  132.               IntPtr offPtr = IntPtr.Add(MemPtr, pos);
  133.               Marshal.Copy(offPtr, datas, 0, dataLength);
  134.           }
  135.           return datas;
  136.       }
  137.  
  138.       /// <summary>
  139.       /// 读取共享内存并返回到类
  140.       /// </summary>
  141.       /// <param name="type">读取的类型</param>
  142.       /// <returns>读取的数据</returns>
  143.       public Object ReadFromMemory(Type type)
  144.       {
  145.           if (IntPtr.Zero == MemPtr)
  146.           {
  147.               return null;
  148.           }
  149.  
  150.           Object obj = Marshal.PtrToStructure(MemPtr, type);
  151.           return obj;
  152.       }
  153.  
  154.       /// <summary>
  155.       /// 读取类并写入共享内存
  156.       /// </summary>
  157.       /// <param name="obj">需要读取的类(结构体)</param>
  158.       /// <returns>返回0表示写入成功，返回-1表示写入失败</returns>
  159.       public int WriteToMemory(Object obj)
  160.       {
  161.           if (IntPtr.Zero == MemPtr)
  162.           {
  163.               return -1;
  164.           }
  165.  
  166.           Marshal.StructureToPtr(obj, MemPtr, false);
  167.  
  168.           return 0;
  169.       }
  170.  
  171.       /// <summary>
  172.       /// 关闭共享内存(解除印射,关闭句柄)
  173.       /// </summary>
  174.       public void ShareMemoryClose()
  175.       {
  176.           if (m_bInit)
  177.           {
  178.               UnmapViewOfFile(m_rwData);
  179.               CloseHandle(m_hSharedMemoryFile);
  180.               m_bInit = false;
  181.           }
  182.       }
  183.  
  184.       /// <summary>
  185.       /// 获取共享内存印射地址
  186.       /// </summary>
  187.       /// <returns></returns>
  188.       public IntPtr GetPtr()
  189.       {
  190.           return MemPtr;
  191.       }
  192.  
  193.       /// <summary>
  194.       /// 获取文件句柄
  195.       /// </summary>
  196.       /// <returns></returns>
  197.       public IntPtr GetFileMapPtr()
  198.       {
  199.           return m_hSharedMemoryFile;
  200.       }
  201.  
  202.       /// <summary>
  203.       /// 获取共享内存大小
  204.       /// </summary>
  205.       /// <returns></returns>
  206.       public long GetSize()
  207.       {
  208.           return MemSize;
  209.       }
  210.  
  211.       /// <summary>
  212.       /// 获取共享内存名字
  213.       /// </summary>
  214.       /// <returns></returns>
  215.       public string GetName()
  216.       {
  217.           return ShareName;
  218.       }
  219.   }

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号