kev/Drawer/RunWellSectionApp/Form1_WellPole.cs

using IPCLib;
using RunWellSectionApp;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Threading;

namespace RunWellSectionApp
{
    partial class Form1
    {
        //IpcPipeClass m_ipcPipeWellPole = null;
        IpcMmfClass m_ipcMmfWellPole = null;
        private void OnMessageReceived(PipeMessage msg)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new Action<PipeMessage>(OnMessageReceived), msg);
                return;
            }
            UpdateStatus($"收到 B: [{msg.Timestamp}] {msg.Content}");
        }

        //private void OnConnectionStatusChanged(bool connected)
        //{
        //    if (this.InvokeRequired)
        //    {
        //        this.Invoke(new Action<bool>(OnConnectionStatusChanged), connected);
        //        return;
        //    }

        //    //var lblStatus = this.Controls.Find("lblStatus", true)[0] as Label;
        //    if (connected)
        //    {
        //        m_ipcPipeWellPole.m_bUsePipe = true;
        //        m_ipcPipeWellPole.m_heartbeatTimeoutCount = 0;
        //        UpdateStatus("状态：已连接 (心跳正常)");
        //    }
        //    else
        //    {
        //        // lblStatus.Text = "状态：断开";
        //        m_ipcPipeWellPole.m_bUsePipe = false;
        //        UpdateStatus("状态：断开");
        //        Trace.WriteLine("状态：断开");
        //    }
        //}
        //private void OnHeartbeatTimeout()
        //{
        //    if (this.InvokeRequired)
        //    {
        //        this.Invoke(new Action(OnHeartbeatTimeout));
        //        return;
        //    }

        //    m_ipcPipeWellPole.m_heartbeatTimeoutCount++;

        //    UpdateStatus($"状态：心跳超时 ({m_ipcPipeWellPole.m_heartbeatTimeoutCount} 次)");
        //    if (m_ipcPipeWellPole.m_heartbeatTimeoutCount >= 3)
        //    {
        //        //AddLog("错误：连续心跳超时，尝试重启进程 B");
        //        m_ipcPipeWellPole.m_heartbeatTimeoutCount = 0;
        //    }
        //}

        private void OnMmfConnected()
        {
            if (InvokeRequired) { Invoke(new Action(OnMmfConnected)); return; }

            UpdateStatus($"建立连接");

        }

        private void OnMmfDisconnected(string reason)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnMmfDisconnected(reason))); return; }
            UpdateStatus($"断开");
            m_ipcMmfWellPole.m_process = null;
            m_ipcMmfWellPole.m_bUse = false;
        }

        private void OnMmfDataReceived(string data)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnMmfDataReceived(data))); return; }

            UpdateStatus($"收到 B: [{data}]");
        }

        private void OnMmfProcessBExited(object sender, EventArgs e)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnMmfProcessBExited(sender, e))); return; }

            if (m_ipcMmfWellPole.m_process != null)
            {
                UpdateStatus($"B 进程已退出 (ExitCode: {m_ipcMmfWellPole.m_process?.ExitCode})");
                m_ipcMmfWellPole.m_process?.Dispose();
                m_ipcMmfWellPole.m_process = null;
                m_ipcMmfWellPole.m_bUse = false;
            }
        }

        private void OnMmfPeerFrozen(string reason)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnMmfPeerFrozen(reason))); return; }
            UpdateStatus($"[{DateTime.Now}] ⚠️ {reason}\n");
        }

        //private void OnMmfPeerFrozen(string reason)
        //{
        //    if (InvokeRequired) { Invoke(new Action(() => OnMmfPeerFrozen(reason))); return; }
        //    UpdateStatus("通讯死机");
        //}

        //private void OnMmfPeerRecovered(string reason)
        //{
        //    if (InvokeRequired) { Invoke(new Action(() => OnMmfPeerRecovered(reason))); return; }
        //    UpdateStatus("通讯恢复");
        //}

        private void OnMmfError(string msg)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnMmfError(msg))); return; }
            UpdateStatus("通讯错误" + msg);
        }

        /// <summary>
        /// ////////////////////////////
        /// </summary>
        /// <param name="newWellName"></param>
        /// <param name="wellsName"></param>
        void startWellProcess(string newWellName, string wellsName)
        {
            //if (m_ipcPipeWellPole.m_process == null || m_ipcPipeWellPole.m_bUsePipe == false)
            if(m_ipcMmfWellPole.m_process == null || m_ipcMmfWellPole.m_bUse == false)
            {
                string fileName = ".\\KEVisualization_wellPole.exe";
                if (!File.Exists(fileName))
                {
                    MessageBox.Show("没有井剖面启动程序");
                    return;
                }

               // m_ipcMmfWellPole.m_mmf.ResetSharedMemoryState();
                Thread.Sleep(300);
                //InitIpc();
                //m_ipcWellPole.m_Port = PortHelper.FindAvailablePort(6790);

                //string args = $" \"workAreaPath={prjfileNamePath}\" \"PipeId={m_ipcPipeWellPole.m_pipeId}\"";
                string args = $" \"workAreaPath={prjfileNamePath}\" \"MemoryId={m_ipcMmfWellPole.m_MemoryId}\"";
                if (newWellName != "")
                {
                    args = args + $" \"newWell={newWellName}\"";
                }
                else if (wellsName != "")
                {
                    args = args + $" \"newWellsSection={wellsName}\"";
                }
                var startInfo = new ProcessStartInfo
                {
                    FileName = fileName,
                    Arguments = args,
                    UseShellExecute = false,
                    CreateNoWindow = false
                };
                try
                {
                    m_ipcMmfWellPole.m_process = Process.Start(startInfo);
                    m_ipcMmfWellPole.m_bUse = true;
                    if(m_ipcMmfWellPole.m_process != null)
                    {
                        m_ipcMmfWellPole.m_process.EnableRaisingEvents = true;
                        m_ipcMmfWellPole.m_process.Exited += OnWellPoleExited;
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show("井剖面模块不能启动，请检查");
                }
            }
        }

        private void OnWellPoleExited(object sender, EventArgs e)
        {
            if (InvokeRequired) { Invoke(new Action(() => OnWellPoleExited(sender, e))); return; }

            if (m_ipcMmfWellPole.m_process != null)
            {
                UpdateStatus($"WellPole 进程已退出 (ExitCode: {m_ipcMmfWellPole.m_process.ExitCode})");
                //m_ipcMmfWellPole.m_process?.Dispose();
                m_ipcMmfWellPole.m_process = null;
                m_ipcMmfWellPole.m_bUse = false;
            }
            // ✅ B 退出后，共享内存状态保留，等下次启动时清理
        }

        async void runWellPole(string newWellName, string wellsName)
        {
            if (m_ipcMmfWellPole == null)
            {
                m_ipcMmfWellPole = new IpcMmfClass();
                m_ipcMmfWellPole.Init(OnMmfDataReceived, OnMmfConnected, OnMmfDisconnected,OnMmfPeerFrozen,OnMmfError);

                //await m_ipcMmfWellPole.m_mmf.StartAsync();

                startWellProcess(newWellName, wellsName);

                return;
            }

            if (m_ipcMmfWellPole.m_bUse == false)
            {
                startWellProcess(newWellName, wellsName);
            }
            else
            {
                string args = "";
                if (newWellName != "")
                {
                    args = args + $"newWell={newWellName}";
                }
                else if (wellsName != "")
                {
                    args = args + $"newWellsSection={wellsName}";
                }

                m_ipcMmfWellPole.m_mmf.SendData(args);
            }
            //if (m_ipcPipeWellPole == null)
            //{
            //    m_ipcPipeWellPole = new IpcPipeClass();
            //    m_ipcPipeWellPole.InitUsePiple(OnMessageReceived, OnConnectionStatusChanged, OnHeartbeatTimeout);
            //    startWellProcess(newWellName, wellsName);

            //    await m_ipcPipeWellPole.m_Pipe.StartAsync();
            //    return;
            //}

            //if (m_ipcPipeWellPole.m_bUsePipe == false)
            //{
            //    startWellProcess(newWellName, wellsName);
            //}
            //else
            //{
            //    string args = "";
            //    if (newWellName != "")
            //    {
            //        args = args + $"newWell={newWellName}";
            //    }
            //    else if (wellsName != "")
            //    {
            //        args = args + $"newWellsSection={wellsName}";
            //    }

            //    PipeMessage msg = new PipeMessage { Type = MessageType.Data, Content = args, Timestamp = DateTime.Now };
            //    m_ipcPipeWellPole.m_Pipe.SendAsync(msg);

            //}
        }

        public void createNewWellPole(string newWellName) //生成单井柱启动函数
        {
            runWellPole(newWellName, "");
        }

        public void createNewWellsSection(List<string> newWells)//生成多井剖面启动函数
        {
            if (newWells == null)
                runWellPole("", "");
            else
            {
                if (newWells.Count == 0)
                {
                    runWellPole("", "");
                }
                else
                {
                    string wellsname = "";
                    for (int i = 0; i < newWells.Count; i++)
                    {
                        wellsname = wellsname + '|' + newWells[i];
                    }

                    wellsname = wellsname.TrimStart('|');

                    runWellPole("", wellsname);
                }
            }
        }

        public void startWellPole()
        {
            runWellPole("", "");
        }

    }
}