基于命名管道（Named Pipes) 的进程间通信（IPC），用于在同一台机器不同进程之间进行高效、可靠的数据传输，是一种基于消息或流的通信机制。管道有一个唯一的名称，客户端和服务器端通过名称连接到同一个管道，支持客户端和服务器端同时发送和接收数据。

以下，是一个C#的实例：

服务器端：

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Threading;
using System.Web;

namespace NamedPipeServerForWindEDB
{
    class Program
    {
        private static bool _isRunning = true;

        static void Main(string[] args)
        {
            Console.WriteLine("与财务分析最终版配称套件，用于更新EDB数据，相应进程已经启动...");

            while (_isRunning)
            {
                using (var pipeServer = new NamedPipeServerStream("WindDataPipe", PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
                {
                    try
                    {
                        Console.WriteLine("等待主程序连接...");
                        pipeServer.WaitForConnection();
                        Console.WriteLine("主程序已连接。");

                        using (var reader = new StreamReader(pipeServer))
                        using (var writer = new StreamWriter(pipeServer))
                        {
                            string command = reader.ReadLine();

                            Console.WriteLine("收到指令: " + command);

                            if (command == "SHUTDOWN")
                            {
                                _isRunning = false;
                                writer.WriteLine("Shutdowning...");
                                writer.Flush();
                              
                            }
                            else
                            {
                                string data = GetDataFromWind(command);
                                writer.WriteLine(data);
                                writer.Flush();
                                Console.WriteLine("数据已返回。");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("发生错误: " + ex.Message);
                    }
                    finally
                    {
                        if (pipeServer.IsConnected)
                        {
                            pipeServer.Disconnect();
                            Console.WriteLine("断开当前连接。");
                        }
                    }
                }
            }

            Console.WriteLine("子进程已关闭。");
        }

        // 模拟调用Wind API获取数据
        static string GetDataFromWind(string request)
        {
            // 这里替换为实际的Wind API调用逻辑
            Thread.Sleep(1000); // 模拟耗时操作


            string strContent = "";

            List<string> Requestitems = request.Split('|').ToList();

            if (Requestitems.Count == 3 )
            {
                string strStart=Requestitems[1];
                string strEnd=Requestitems[2];

                List<string> EDBCodes = Requestitems[0].Split(';').ToList();


                foreach (string strCode in EDBCodes)                
                {
                    strContent = strContent + strCode + strStart + strEnd + "|";
                } 
            }
            return #34;数据来自Wind API，请求内容: {strContent}";
        }

    }
}

客户端：

using System;
using System.Diagnostics;
using System.IO.Pipes;
using System.Windows.Forms;

namespace WinFormsApp1
{
    public partial class Form1 : Form
    {
        private Process subProcess = new Process(); // 子进程对象
        private bool isSubProcessRunning = false; // 标记子进程是否已启动

        public Form1()
        {
            InitializeComponent();
        }

        // 启动子进程按钮点击事件
        private void button1_Click(object sender, EventArgs e)
        {

            if (!isSubProcessRunning)
            {
                // 启动.NET 4.8子进程
                subProcess = StartSubProcess();
                isSubProcessRunning = true;
            }

            // 发送请求
            SendRequest("windEDBCode1;windEDBCode2;windEDBCode3|2023-01-01|2024-01-01");
        }

        // 启动子进程
        private Process StartSubProcess()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                FileName = @"D:\我的云文档\C#程序开发\NamedPipeServerForWindEDB\bin\Debug\NamedPipeServerForWindEDB.exe", // 替换为子进程的路径
                UseShellExecute = false,
                CreateNoWindow = true
            };

            Process subProcess = new Process { StartInfo = startInfo };
            subProcess.Start();
            return subProcess;
        }

        private void SendRequest(string request)
        {
            try
            {
                using (var pipeClient = new NamedPipeClientStream(".", "WindDataPipe", PipeDirection.InOut, PipeOptions.Asynchronous))
                {
                    pipeClient.Connect(5000); // 设置连接超时

                    using (var writer = new StreamWriter(pipeClient))
                    using (var reader = new StreamReader(pipeClient))
                    {
                        writer.WriteLine(request);
                        writer.Flush();

                        string data = reader?.ReadLine()??""; // 等待服务器端返回数据

                        this.Invoke((MethodInvoker)delegate
                        {

                            if (data.Contains("Shutdowning..."))
                            {
                                //  忽略
                            }
                            else
                            {
                                MessageBox.Show("收到数据: " + data);
                            }
                            
                        });
                    }
                }
            }
            catch (TimeoutException)
            {
                MessageBox.Show("连接子进程超时，请检查子进程是否已启动。");
            }
            catch (Exception)
            {
              
            }
        }

        // 窗体关闭事件
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 检查子进程是否正在运行
            if (isSubProcessRunning && subProcess != null && !subProcess.HasExited)
            {
                try
                {
                    // 发送关闭指令
                    SendRequest("SHUTDOWN");

                    // 等待子进程退出
                    if (!subProcess.WaitForExit(5000)) // 设置超时时间（例如5秒）
                    {
                        MessageBox.Show("子进程未正常退出，已强制终止。");
                        subProcess.Kill(); // 强制终止子进程
                    }
                }
                catch (Exception)
                {
                   
                }
                finally
                {
                    // 标记子进程已关闭
                    isSubProcessRunning = false;
                }
            }        
           
        }
    }
}

返回的结果