进程间通信的一个方法(.NET)

最新推荐文章于 2025-07-20 11:18:41 发布
原创 最新推荐文章于 2025-07-20 11:18:41 发布 · 3k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#.net #byte #exception #string #c#
#fun
本文介绍了一种基于共享内存的C#进程间通信方法，适用于同一系统内的C#程序。文章详细展示了如何创建和使用共享内存，以及如何通过循环检查共享内存实现进程间的消息传递。
环境:VS2005 C# WinForm

注：我的方法仅适用于同一系统内的进程,并且相关进程都是您自己编写的C#程序。


网上关于C#进程间通信的资料：WM_COPYDATA、共享内存、管道、消息队列、SOCKET...
其中WM_COPYDATA是最简单的，但它受制于窗口。当窗口不处在顶层时，WM_COPYDATA就可能失效。共享内存是较为基

础的一种办法，但要用好它需要一些技巧。另外小弟对进程间消息传递的及时性非常看重，希望一个进程发出消息后

，目标进程能够立即做出反应。但是进程边界决定了这是不可能的，因为发送消息的进程不可能直接调用目标进程里

的函数。归根结底，目标进程得自己通过循环来查看外面是否有属于自己的消息。WM_COPYDATA是通过窗口消息循环

来获取，其它几种方法则是在内部通过一个while循环来获取信息。因为要避免这个while循环影响到UI线程，所以必

需另开线程。在了解了进程间通迅一些基础原理后，小弟总结出自己的方法。其原理是：

以共享内存为基础，发送方将消息码(代表了消息含义)及消息相关数据，以及接收进程的标识(进程ID或主窗口Text)

都放到共享内存中。接收方则循环检查共享内存中有无属于自己的消息数据，若有则取出处理。处理完后接收方将共

享内存数据清空。
理论上需要对共享内存的写操作进行同步，不过目前没提供同步代码(小弟工程中不需要，所以懒得弄了...)


首先是共享内存操作类，用于进程间数据传递。可根据需要对其进行修改以附合您要求，比如其中结构体定义。
C# code 
            

             
             
    
             public
              
             static
              
             class
              ProcessMessaging
    {
        
             static
              ShareMem Data 
             =
              
             new
              ShareMem();

        
             ///
              
             <summary>
             
        
             ///
              获取共享内存(MyData结构)
        
             ///
              
             </summary>
             
        
             ///
              
             <returns></returns>
             

                     
             public
              
             static
              MyData GetShareMem()
        {
            
             int
              MemSize 
             =
              Marshal.SizeOf(
             typeof
             (MyData));

            
             if
              (Data.Init(
             "
             MyData
             "
             , MemSize) 
             !=
              
             0
             )
            {
                
             return
              
             new
              MyData(
             -
             1
             );
            }

            
             byte
             [] temp 
             =
              
             new
              
             byte
             [MemSize];

            
             try
             
            {
                Data.Read(
             ref
              temp, 
             0
             , temp.Length);
                MyData stuc 
             =
              (MyData)Tools.BytesToStuct(temp, 
             typeof
             (MyData));
                
             return
              stuc;
            }
            
             catch
              (Exception)
            {
                
             return
              
             new
              MyData(
             -
             1
             );
            }
        }
             //
             end fun
             

             
        
             ///
              
             <summary>
             
        
             ///
              设置共享内存(MyData结构)
        
             ///
              
             </summary>
             
        
             ///
              
             <param name="str"></param>
             
        
             ///
              
             <returns></returns>
             

                     
             public
              
             static
              
             bool
              SetShareMem(MyData data)
        {
            
             int
              MemSize 
             =
              Marshal.SizeOf(
             typeof
             (MyData));

            
             if
              (Data.Init(
             "
             MyData
             "
             , MemSize) 
             !=
              
             0
             )
             //
             "MyData"共享内存名称,您起别的名字也可以
             

                         {
                
             return
              
             false
             ;
            }

            
             try
             
            {
                
             byte
             [] b 
             =
              Tools.StructToBytes(data);
                Data.Write(b, 
             0
             , b.Length);
            }
            
             catch
              (Exception)
            {
                
             return
              
             false
             ;
            }
            
             return
              
             true
             ;
        }
             //
             end fun
             

                 }
             //
             end class
             

             
    
             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
             )
                    {
                        
             //
             初始化
             

                                     MyData data 
             =
              
             new
              MyData(
             -
             1
             );
                        
             byte
             [] bd 
             =
              Tools.StructToBytes(data);
                        Marshal.Copy(m_pwData, bd, 
             0
             , bd.Length);
                    }
                }
                
             //
             ----------------------------------------
             

                         }
            
             else
             
            {
                
             return
              
             1
             ; 
             //
             参数错误     
             

                         }

            
             return
              
             0
             ;     
             //
             创建成功
             

                     }
             //
             end fun
             

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

                     }
    }
             //
             end class


--下面继续
 
 

 

 

 

 
C# code 
            

             
             
    
             //
             根据需要扩展该结构体
             

                 [StructLayout(LayoutKind.Sequential, Pack 
             =
              
             4
             , CharSet 
             =
              CharSet.Unicode)]
    
             public
              
             struct
              MyData
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst 
             =
              
             1024
             )]
        
             public
              
             char
             [] c0;
        
             public
              
             int
              l0;

        
             public
              
             int
              i0;
        
             public
              
             int
              i1;
        
             public
              
             int
              i2;
        
             public
              
             int
              i3;
        
             public
              
             int
              i4;
        
             public
              
             int
              i5;

        
             //
             placeholder：该参数我用不着,可C#规定必需有,所以起个这名字
             

                     
             public
              MyData(
             int
              placeholder)
        {
            c0 
             =
              
             new
              
             char
             [
             1024
             ];
            l0 
             =
              
             0
             ;     
            i0 
             =
              
             0
             ;
            i1 
             =
              
             0
             ;
            i2 
             =
              
             0
             ;
            i3 
             =
              
             0
             ;
            i4 
             =
              
             0
             ;
            i5 
             =
              
             0
             ;
        }
             //
             end fun
             

             
        
             ///
              
             <summary>
             
        
             ///
              进程间通信，进程ID,-2表示所有进程
        
             ///
              
             </summary>
             

                     
             public
              
             int
              ProcessID
        {
            
             get
             
            { 
             return
              i4; }
            
             set
             
            {

                i4 
             =
              value;
            }
        }

        
             ///
              
             <summary>
             
        
             ///
              进程间通信,消息码
        
             ///
              
             </summary>
             

                     
             public
              
             int
              InfoCode
        {
            
             get
             
            { 
             return
              i5; }
            
             set
             
            { i5 
             =
              value; }
        }

        
             ///
              
             <summary>
             
        
             ///
              示例字符串参数
        
             ///
              
             </summary>
             

                     
             public
              
             string
              Url
        {
            
             get
             
            {
                
             if
              (l0 
             >
              
             0
             )
                { 
             return
              
             new
              
             string
             (c0, 
             0
             , l0); }
                
             else
             
                {
                    
             return
              
             ""
             ;
                }
            }
            
             set
             
            {
                
             if
              (value 
             !=
              
             null
             )
                {
                    value.CopyTo(
             0
             , c0, 
             0
             , value.Length);
                    l0 
             =
              value.Length;
                }
            }
        }

        
             ///
              
             <summary>
             
        
             ///
              示例矩形参数
        
             ///
              
             </summary>
             

                     
             public
              Rectangle WindowPosition
        {
            
             get
             
            { 
             return
              
             new
              Rectangle(i0, i1, i2, i3); }
            
             set
             
            {
                i0 
             =
              value.X;
                i1 
             =
              value.Y;
                i2 
             =
              value.Width;
                i3 
             =
              value.Height;
            }
        }
    }
             //
             end struct
             

             

    
             public
              
             static
              
             class
              Tools
    {
        
             //
             序列化结构体复制入byte数组
             

                     
             public
              
             static
              
             byte
             [] StructToBytes(
             object
              structObj)
        {
            
             //
             得到结构体的大小
             

                         
             int
              size 
             =
              Marshal.SizeOf(structObj);
            
             //
             创建byte数组
             

                         
             byte
             [] bytes 
             =
              
             new
              
             byte
             [size];
            
             //
             分配结构体大小的内存空间
             

                         IntPtr structPtr 
             =
              Marshal.AllocHGlobal(size);
            
             //
             将结构体拷到分配好的内存空间
             

                         Marshal.StructureToPtr(structObj, structPtr, 
             false
             );
            
             //
             从内存空间拷到byte数组
             

                         Marshal.Copy(structPtr, bytes, 
             0
             , size);
            
             //
             释放内存空间
             

                         Marshal.FreeHGlobal(structPtr);
            
             //
             返回byte数组
             

                         
             return
              bytes;
        }

        
             //
             byte数组复制入序列化结构体,注意在返回结果前加上强制转换
             

                     
             public
              
             static
              
             object
              BytesToStuct(
             byte
             [] bytes, Type type)
        {
            
             //
             得到结构体的大小
             

                         
             int
              size 
             =
              Marshal.SizeOf(type);
            
             //
             byte数组长度小于结构体的大小
             

                         
             if
              (size 
             >
              bytes.Length)
            {
                
             //
             返回空
             

                             
             return
              
             null
             ;
            }
            
             //
             分配结构体大小的内存空间
             

                         IntPtr structPtr 
             =
              Marshal.AllocHGlobal(size);
            
             //
             将byte数组拷到分配好的内存空间
             

                         Marshal.Copy(bytes, 
             0
             , structPtr, size);
            
             //
             将内存空间转换为目标结构体
             

                         
             object
              obj 
             =
              Marshal.PtrToStructure(structPtr, type);
            
             //
             释放内存空间
             

                         Marshal.FreeHGlobal(structPtr);
            
             //
             返回结构体
             

                         
             return
              obj;
        }
             //
             end fun
             

                 }
             //
             end class


如果要向一个进程发送消息：
C# code 
            

             
             
                    MyData data 
             =
              ProcessMessaging.GetShareMem();
             //
             您new一个也行
             

                                 data.InfoCode 
             =
              ...;
             //
             消息码
             

                                 data.ProcessID 
             =
              ...;
             //
             接收进程ID
             

                                 ...其它数据
                    ProcessMessaging.SetShareMem(data);



接下来说下接收方,以下代码都位于主窗口CPP中：

  int ProcessID = 0;
  System.Timers.Timer time = new System.Timers.Timer(10);//实例化Timer类，设置间隔时间为10毫秒；

  下面4行代码在构造函数中添加：
  ProcessID = Process.GetCurrentProcess().Id;
  time.Elapsed += new System.Timers.ElapsedEventHandler(theout);//到达时间的时候执行事件； 
  time.AutoReset = true;//设置是执行一次（false）还是一直执行(true)； 
  time.Enabled = false;//是否执行System.Timers.Timer.Elapsed事件；
  //load事件中启动time


  public void theout(object source, System.Timers.ElapsedEventArgs e)
  {
  ProcessMessageHandler pmh = new ProcessMessageHandler(ProcessMessage);
  this.Invoke(pmh);
  }//end fun

  public delegate void ProcessMessageHandler();

  public void ProcessMessage()
  {
  MyData data = ProcessMessaging.GetShareMem();
  if (data.ProcessID == ProcessID)
  {
  switch (InfoCode)
  {
  ...处理
  }
  }
  ...清空data
  ProcessMessaging.SetShareMem(data);
  } 


.NET 进程间通信框架 — SimpleMMF
weixin_68436326的博客
06-08 415
一、前言进程间通信技术的应用非常广泛，在Windows下常用的实现方式有：管道、Socket、消息、本地文件、共享内存等，每种方式都有各自适应的场景。在进行大数据交换时，最优的方式便是共享内存。但是共享内存在应用时往往需要配合其他的进程间通信方式，比如管道、消息等，用以通知共享内存中的数据发生了改变，所以共享内存在实际应用时是很繁琐的。本框架——SimpleMMF，便是为解决这个痛点所开发的。本框...
进程间通信
weixin_46829095的博客
03-24 1255
进程间通信（interprocess communication，简称 IPC） 指两个进程之间的通信。系统中的每一个进程都有各自的地址空间，并且相互独立、隔离， 每个进程都处于自己的地址空间中。所以同一个进程的不同模块（譬如不同的函数）之间进行通信都是相对简单的，譬如使用全局变量等但是，两个不同的进程之间要进行通信通常是比较难的，因为这两个进程处于不同的地址空间中；通常情况下，大部分的程序是不要考虑进程间通信的，对于一些复杂、大型的应用程序，则会根据实际需要将其设计成多进程程序。
温故之.NET进程间通信——管道
极客神殿
04-06 1334
进程间传递数据，常见的有以下几种方式： 管道：包括命名管道和匿名管道，这篇文章将讲解这种方式 内存映射文件：借助文件和内存空间之间的映射关系，应用（包括多个进程）可以直接对内存执行读取和写入操作，从而实现进程间通信 Socket：使用套接字在不同的进程间通信，这种通信方式下，需要占用系统至少一个端口 SendMessage：通过窗口句柄的方式来通信，此通信方式基于 Windows 消息 WM_COPYDATA 来实现 消息队列：在对性能要求不高的情况下，我们可以使用 Msmq。但在实际项目中，一般使用Ac
浅谈进程通信
qq_51143945的博客
08-22 959
对进程通信的理解
温故之.NET进程间通信——内存映射文件
qq_44005305的博客
02-23 480
上一篇技术文章中，我们讲解了进程间通信中的管道通信方式，这只是多种进程间通信方式中的一种，这篇文章我们回顾一下另一种进程间通信的方式——内存映射文件。
.NET多进程间进行互相通讯
SANTOOK的专栏
04-21 6447
在实际应用中我们经常需要实现多个进程之间共享信息，以及实现互相之间的控制传递。 我们可以有很多的方法，最为常用的是共享一个本地的数据文件，或者是共享一个数据库。但问题也随之而来——不断的对硬盘进行操作会对硬盘硬件造成极大的伤害，另外由于读取硬盘需要大量的时间，也同样对软件的运行效率大打折扣！ 因此，更为高级的就是我们共享内存！过去在C/C++中这个似乎比较便捷，但VB6中则需要很多API操作才
利用IPC通道进行进程间通信（C#）
涛哥向上专栏
05-14 1376
有一个解决方案，其中包括一个Windows服务和一个Windows应用程序，两者之间需要进行通信。查了下，可以使用多种方法，如Web service（适用于不同系统及跨平台情况）、.NET Remoting、消息队列、WCF（集成了前述方法的功能，但太新，不支持Windows2000及以前的系统），其中Remoting可以支持TCP、HTTP、IPC通道的通信，而IPC通道速度快，且仅能供处于同一
C#使用共享内存实现进程间的通信
热门推荐
codeofcc的博客
09-26 1万+
进程通信有多种方式，比如socket、管道、共享内存。c#直接提供了共享内存的相关库，但直接使用起来还是不太方便，需要使用Marshal处理内存对齐以及托管非托管转换的问题，本文提供一种，将上述操作包装，借助反射的手段，实现通过类和属性的方式使用共享内存。 一、.net共享内存对象 MemoryMappedFile是.net的共享内存对象，一般通过MemoryMappedFile.CreateNew的方式创建共享内存，最简单的创建方式是，传入名称及大小。 //申请共享内存 MemoryMapped
.net/C#进程间通信技术方案总结
yuanpan的专栏
05-09 690
C#中常用的进程间通信（IPC）技术方案包括命名管道、内存映射文件、WCF、套接字、消息队列、文件监视和COM/DCOM。命名管道适用于本地机器上的双向通信，内存映射文件通过共享内存实现高效通信，WCF支持多种协议，套接字适用于网络和本地通信，消息队列提供可靠的异步通信，文件监视通过共享文件和文件系统事件进行通信，COM/DCOM则用于与遗留系统或非.NET应用程序集成。选择IPC技术时，应根据具体需求如性能、跨机器通信、可靠性和系统集成等因素进行权衡。
进程间基于消息队列的通信_使用内存映射开发高性能进程间消息通信组件
weixin_39804620的博客
11-25 232
一、背景项目开发中免不了各模块或系统之间进行消息通信，目前热门的消息中间件有Redis、RabbitMQ、Kafka、RocketMQ等等。以上几种组件中Redis在消息队列方面表现还可以，但是如果涉及发布订阅功能，就不行了，最近项目就使用了redis的发布订阅，每秒只能发出几千条，虽然目前绰绰有余，但是瓶颈可以预期。其余的几种都是比较重量级的消息中间件，什么跨平台、分布式、集群、支持N种协议等等...
.NET跨进程通信的实现方式
.Net技术、软件架构、人工智能、数字化转型、DeveloperSharp、微服务、工业互联网、智能制造
12-15 1232
🏆作者：科技、互联网行业优质创作者🏆专注领域：.Net技术、软件架构、人工智能、数字化转型、DeveloperSharp、微服务、工业互联网、智能制造🏆欢迎关注我（），里面有很多技术文章，，能助你快速成长。升职+涨薪！！在WPF中，实现跨进程通信通常可以使用.NET Framework提供的一些功能，例如WCF和命名管道。以下是使用WCF和命名管道实现跨进程通信的示例：**
推荐一款基于.NET的进程间通信框架
最新发布
绳锯木断，水滴石穿，专心写文，无问西东！！！
07-20 1145
在Windows操作系统中，每一个应用程序都是相互独立的，它们拥有独立的内存空间，各个应用程序之间形成一道边界，不能互相访问和操作，这是操作系统为了保护应用程序的安全而设计的。这种看似“井水不犯河水”的设计同样有它的弊端，假如两个应用程序需要相互协作配合才能完成工作，那它们就需要进行通信和数据交互，今天以一个简单的小例子，简述一种基于.NET的进程间通信的方案Remoting技术，仅供学习分享使用，如有不足之处，还请指正。
探索高效进程间通信的佳选：IpcServiceFramework
gitblog_00640的博客
08-27 1029
探索高效进程间通信的佳选：IpcServiceFramework 在现代软件开发中，进程间的通信（IPC）是一项至关重要的技术。它允许不同的程序组件在同一个或不同计算机上无缝交换数据，是构建高性能、可扩展系统的基础。今天，我们向您隆重推介——IpcServiceFramework，一个基于.NET Core 3.1的轻量级IPC框架，它为开发者打开了效率和灵活性并存的新大门。 项目介绍 IpcSe...
.Net Core3.1 微服务架构技术栈
何足道也
04-12 6605
微服务这个概念早在2012年就提出来了，经过了这些年的发展，现在已经成为企业非常主流的架构选项了。 微服务的前世今生 与微服务架构相对的，叫单体架构。这是我们最熟悉的开发方式，就是一个项目搞定业务全过程，在同一个进程里面完成。随着业务发展，数据量和并发上去了，一般会选择右边的垂直拆分，拆分后的每个系统，依旧是单体架构的。 垂直拆分后，子系统都能独立做集群，承载能力大...
NET Core使用gRPC打造服务间通信基础设施
极客神殿
03-13 1451
一、什么是RPC rpc（远程过程调用）是一个古老而新颖的名词，他几乎与http协议同时或更早诞生，也是互联网数据传输过程中非常重要的传输机制。 利用这种传输机制，不同进程（或服务）间像调用本地进程中的方法一般进行交互，而无需关心实现细节。 rpc的主要实现流程为： 图1：RPC 调用流程 1、客户端本地方法调用客户端stub（方法存根）。这个调用发生在客户端本地，并把调用参数推送到栈中。 2、客户端stub (方法存根）将这些参数打包，通过系统调用发送到服务器机器。打包的过程通常可以采用xml、json
.NET TCP、UDP、Socket、WebSocket
chinaherolts2008的博客
08-14 510
HttpClient使用 HTTP 协议，WebSocket使用WebSocket协议，该协议在初始连接时通过 HTTP/HTTPS握手，然后转换为基于TCP通信的WebSocket协议。Http与TCP/UDP均是网络通信协议，TCP、UDP位于传输层，HTTP传于应用层，而且HTTP是基于TCP面向连接的，它是客户端单向发起的半双工协议。而UDP则是无连接的，不需要建立和维护连接状态，不提供确认机制，也不重传丢失的数据报，但也因此传输实时性高，适合低延时、数据量小、广播场景。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值