wpf中嵌入另一个子进程exe像本地的一个页面那样

//新的一个子进程浏览器
private void OpenNewWebBrowser(string webBrowserName, string url)
{
IntPtr targetPtr = this.CreateWebProcess();

IntPtr pagePtr = this.GetOrAddNewPage(webBrowserName, url);

lock (_lockObj)
{
_webBrowserPtr.Add(webBrowserName, targetPtr);
}

this.SetWebBrowserLoc(webBrowserName, pagePtr);

this.SendParam(webBrowserName, url);
}


//创建一个新的webbrowser进程
private IntPtr CreateWebProcess()
{
ProcessStartInfo psi = new ProcessStartInfo(_webBrowserStartPath);
psi.WindowStyle = ProcessWindowStyle.Hidden;
var process = Process.Start(psi);
IntPtr targetPtr = IntPtr.Zero;
while (targetPtr == IntPtr.Zero) //循环目标窗口启动完成
{
targetPtr = process.MainWindowHandle;
if (targetPtr != IntPtr.Zero)
{
break;
}
Thread.Sleep(10);
}
return targetPtr;
}

private IntPtr GetOrAddNewPage(string webBrowserName, string url)
        {
           // if (!_urlAndPanelPtr.ContainsKey(url))
            {
                System.Windows.Forms.Panel p = new System.Windows.Forms.Panel();
                WindowsFormsHost host = new WindowsFormsHost();
                host.Tag = webBrowserName;
                host.Background = Brushes.Transparent;
                host.Child = p;

                host.Visibility = System.Windows.Visibility.Visible;
                _webContainer.Children.Add(host);

              //  lock (_lockObj)
               //     _urlAndPanelPtr.Add(url, p.Handle);
                return p.Handle;// 允许一个地址打开多个
            }
           // return _urlAndPanelPtr[url];
        }

 //设置浏览器位置
        private void SetWebBrowserLoc(string webBrowserName, IntPtr pagePtr)
        {
            if (!_webBrowserPtr.ContainsKey(webBrowserName))
                return;

            IntPtr webBrowserPtr = _webBrowserPtr[webBrowserName];

            double h = _webContainer.ActualHeight;

            double w = _webContainer.ActualWidth;

            IntPtr preParentHandle=  Win32Helper.SetParent(webBrowserPtr, pagePtr);

            //如果设置父窗体失败，则重试5次
            int tryNum = 5;
            while(preParentHandle==IntPtr.Zero)
            {
                Thread.Sleep(10);

                preParentHandle = Win32Helper.SetParent(webBrowserPtr, pagePtr);

                if (tryNum <= 0) break;

                tryNum--;
            }

            bool moveResult= Win32Helper.MoveWindow(webBrowserPtr, 0, 0, (int)w, (int)h, true);

            //如果窗体位置移动失败，则尝试5次
            tryNum = 5;
            while(!moveResult)
            {
                Thread.Sleep(10);
                moveResult = Win32Helper.MoveWindow(webBrowserPtr, 0, 0, (int)w, (int)h, true);
                if (tryNum <= 0) break;

                tryNum--;
            }
        }







 public class WebEmbedHelper: IWebEmbedHelper
    {
        string _isNeedReflesh = "0";//是否需要刷新url页面
        readonly Grid _webContainer = null;
        /// <summary>
        /// webbrowser容器句柄
        /// </summary>
        readonly IntPtr _parentIntPrt;
        static Dictionary<string, IntPtr> _urlAndPanelPtr = new Dictionary<string, IntPtr>();//url- panel句柄
        static Dictionary<string, IntPtr> _webBrowserPtr = new Dictionary<string, IntPtr>();//名称 - webbrowser窗体句柄
        static Dictionary<string, IntPtr> _urlAndBroserPrt = new Dictionary<string, IntPtr>();//url -webbrowser窗体句柄
        //url - 回调函数
        static Dictionary<string, Action<string, string>> _msgCallBackDic = new Dictionary<string, Action<string, string>>();
        readonly string _webBrowserStartPath;

         string _currentOpenUrl;//当前打开的url页面
         IntPtr _webProcessPtr;//当前的WebBrowser进程句柄
         bool _isChrome = false;
        public  IntPtr WebProcessPtr
         {
            get
             {
                 return _webProcessPtr;
             }
            set
             {
                 _webProcessPtr = value;
             }
         }
        public Action<int, object> GetWinAction { get; set; }//获取主客户端进程消息的action

        static object _lockObj = new object();

        /// <summary>
        /// WebBrowser构造函数
        /// </summary>
        /// <param name="parentIntPrt">WebBrowser容器父窗体句柄</param>
        /// <param name="grid">用于装载WebBrowser的容器</param>
        /// <param name="webBrowserStartPath">WebBrowser启动完整路径</param>
        public WebEmbedHelper(IntPtr parentIntPrt, Grid grid, string webBrowserStartPath)
        {
            _parentIntPrt = parentIntPrt;
            _webContainer = grid;
            _webBrowserStartPath = webBrowserStartPath;

            this.GetWinAction = ReceiveWinMsg;

            _webContainer.SizeChanged += webContainer_SizeChanged;
        }

        //窗体大小变更，对应的页面也应该自适应
        private void webContainer_SizeChanged(object sender, System.Windows.SizeChangedEventArgs e)
        {
            double w = _webContainer.ActualWidth;
            double h = _webContainer.ActualHeight;
            foreach (var itm in _webBrowserPtr)
            {
                Win32Helper.MoveWindow(itm.Value, 0, 0, (int)w, (int)h, true);
            }
        }

        #region//打开web相关的私有方法
        private IntPtr GetOrAddNewPage(string webBrowserName, string url)
        {
           // if (!_urlAndPanelPtr.ContainsKey(url))
            {
                System.Windows.Forms.Panel p = new System.Windows.Forms.Panel();
                WindowsFormsHost host = new WindowsFormsHost();
                host.Tag = webBrowserName;
                host.Background = Brushes.Transparent;
                host.Child = p;

                host.Visibility = System.Windows.Visibility.Visible;
                _webContainer.Children.Add(host);

              //  lock (_lockObj)
               //     _urlAndPanelPtr.Add(url, p.Handle);
                return p.Handle;// 允许一个地址打开多个
            }
           // return _urlAndPanelPtr[url];
        }

        private void FindAndOpenWebBrowser(string webBrowserName, string url)
        {
            if (!_webBrowserPtr.ContainsKey(webBrowserName))
            {
                this.OpenNewWebBrowser(webBrowserName, url);
            }
            else
            {
                OpenExistWebBrowser(webBrowserName, url);
            }
        }

        //打开新的浏览器
        private void OpenNewWebBrowser(string webBrowserName, string url)
        {
            IntPtr targetPtr = this.CreateWebProcess();
         
            IntPtr pagePtr = this.GetOrAddNewPage(webBrowserName, url);

            lock (_lockObj)
            {
                _webBrowserPtr.Add(webBrowserName, targetPtr);
            }

            this.SetWebBrowserLoc(webBrowserName, pagePtr);

            this.SendParam(webBrowserName, url);
        }
        //打开已存在的页面
        private void OpenExistWebBrowser(string webBrowserName, string url)
        {
            //显示隐藏窗体
            foreach (var itm in _webContainer.Children)
            {
                WindowsFormsHost wfh = itm as WindowsFormsHost;
                if (wfh == null) continue;
                if (wfh.Tag.ToString() == webBrowserName)
                    wfh.Visibility = Visibility.Visible;
                else
                    wfh.Visibility = Visibility.Collapsed;
            }

            IntPtr webBrowserPtr = _webBrowserPtr[webBrowserName];

            double h = _webContainer.ActualHeight - 10;

            double w = _webContainer.ActualWidth - 10;

            Win32Helper.MoveWindow(webBrowserPtr, 0, 0, (int)w, (int)h, true);

            this.SendParam(webBrowserName, url);
        }
        //设置浏览器位置
        private void SetWebBrowserLoc(string webBrowserName, IntPtr pagePtr)
        {
            if (!_webBrowserPtr.ContainsKey(webBrowserName))
                return;

            IntPtr webBrowserPtr = _webBrowserPtr[webBrowserName];

            double h = _webContainer.ActualHeight;

            double w = _webContainer.ActualWidth;

            IntPtr preParentHandle=  Win32Helper.SetParent(webBrowserPtr, pagePtr);

            //如果设置父窗体失败，则重试5次
            int tryNum = 5;
            while(preParentHandle==IntPtr.Zero)
            {
                Thread.Sleep(10);

                preParentHandle = Win32Helper.SetParent(webBrowserPtr, pagePtr);

                if (tryNum <= 0) break;

                tryNum--;
            }

            bool moveResult= Win32Helper.MoveWindow(webBrowserPtr, 0, 0, (int)w, (int)h, true);

            //如果窗体位置移动失败，则尝试5次
            tryNum = 5;
            while(!moveResult)
            {
                Thread.Sleep(10);
                moveResult = Win32Helper.MoveWindow(webBrowserPtr, 0, 0, (int)w, (int)h, true);
                if (tryNum <= 0) break;

                tryNum--;
            }
        }
        //向浏览器发送数据
        private void SendParam(string webBrowserName, string url)
        {
            if (!_webBrowserPtr.ContainsKey(webBrowserName))
                return;

            _webProcessPtr = _webBrowserPtr[webBrowserName];

            UrlModel um = new UrlModel() { Url = url, isChrome = _isChrome };

            if (this._isNeedReflesh == "1")
                um.IsNeedRefresh = true;

            //发送message
            this.SendMessage(um);
        }


        public void SendLoadedParam(string pMsgId, string pUrl)
        {

            UrlModel um = new UrlModel() { MsgId = pMsgId, Url = pUrl };
            //发送message
            this.SendMessage(um);
        }

        #endregion

        //创建一个新的webbrowser进程
        private IntPtr CreateWebProcess()
        {
            ProcessStartInfo psi = new ProcessStartInfo(_webBrowserStartPath);
            psi.WindowStyle = ProcessWindowStyle.Hidden;
            var process = Process.Start(psi);
            IntPtr targetPtr = IntPtr.Zero;
            while (targetPtr == IntPtr.Zero) //循环目标窗口启动完成
            {
                targetPtr = process.MainWindowHandle;
                if (targetPtr != IntPtr.Zero)
                {
                    break;
                }
                Thread.Sleep(10);
            }
            return targetPtr;
        }
        /// <summary>
        /// 接收web页面JS调用发送的数据
        /// </summary>
        private void ReceiveWinMsg(int index,object msg)
        {
            if (msg == null) return;
            string data = msg.ToString();

            if (!data.Contains("MsgId")) return;

            ////js->web->web进程-->客户端主进程
            JsInvokeClientModel jm = JsonConvert.DeserializeObject<JsInvokeClientModel>(data);
            if (jm != null && _msgCallBackDic.ContainsKey(jm.Url))
            {
                //将web页面js调用的参数回调到具体订阅的业务模块中
                _msgCallBackDic[jm.Url](jm.Cmd, jm.Params);
            }

            //客户端主进程->web进程->js
            ClientInvokeJsModel jsResp = JsonConvert.DeserializeObject<ClientInvokeJsModel>(data);
            if (jsResp != null && _jsCallBackData.ContainsKey(jsResp.MsgId))
            {
                jsResp.IsCompleted = true;
                _jsCallBackData[jsResp.MsgId] = jsResp;
            }
        }
        /// <summary>
        /// 发送message
        /// </summary>
        /// <param name="message"></param>
        private void SendMessage(MessageBase message)
        {
            ////将message序列化为json传输
            string json = JsonConvert.SerializeObject(message);
            byte[] sarr = System.Text.Encoding.Default.GetBytes(json);
            int len = sarr.Length;
            CopyDataStruct cds = new CopyDataStruct
            {
                DwData = (IntPtr)100,
                LpData = json,
                CbData = len + 1
            };
          var value=   Win32Helper.SendMessage(this._webProcessPtr, WmConst.WM_COPYDATA, this._parentIntPrt, ref cds);
        }

       

        #region//Interface实现
        public void Open(string url, string webBrowserName = null, bool isNeedReflesh = false, Action<string, string> callBack = null, bool  pIsChrome=false)
        {
            _currentOpenUrl = url;
            _isChrome = pIsChrome;
            _isNeedReflesh = isNeedReflesh ? "1" : "0";

            if (string.IsNullOrEmpty(webBrowserName))
                webBrowserName = "defaultName";

            //IE浏览器打开方式：查找webBrowser进程窗体句柄
            this.FindAndOpenWebBrowser(webBrowserName, url);
            //谷歌的打开方式

            //绑定委托
            if (callBack != null)
            {
                if (!_msgCallBackDic.ContainsKey(url))
                    _msgCallBackDic.Add(url, callBack);
                else
                    _msgCallBackDic[url] = callBack;
            }

            // 移除允许 一个url地址 多个窗体打开
            //if (!_urlAndBroserPrt.ContainsKey(url) && _webBrowserPtr.ContainsKey(webBrowserName))
            //{
            //    _urlAndBroserPrt.Add(url, _webBrowserPtr[webBrowserName]);
            //}
        }

        public void Close(string webBrowserName, string url = null)
        {
            //特殊处置，为了兼容模块嵌入页面同时“设置”项也嵌入页面问题，先查询key的前6位
            if (webBrowserName.Length > 6)
                webBrowserName = webBrowserName.Substring(0, 6);

            List<string> delKeys = new List<string>();
            foreach(var itm in _webBrowserPtr)
            {
                if(itm.Key.Contains(webBrowserName))
                {
                    delKeys.Add(itm.Key);
                }
            }

            foreach(var key in delKeys)
            {
                if (_webBrowserPtr.ContainsKey(key))
                {
                    IntPtr ptr = _webBrowserPtr[key];
                    //发送关闭命令
                    Win32Helper.SendMessage(ptr, WmConst.C_WM_CLOSE, 0, 0);
                    _webBrowserPtr.Remove(key);
                }
            }
            
            if (!string.IsNullOrEmpty(url))
            {
                //_urlAndPanelPtr.Remove(url);
                _msgCallBackDic.Remove(url);
            }
        }

        static Dictionary<string, ClientInvokeJsModel> _jsCallBackData = new Dictionary<string, ClientInvokeJsModel>();
        //public async Task<object> InvokeScript(string scriptName)
        //{
        //   return await this.InvokeScript(scriptName, null);
        //}

        //public async Task<object> InvokeScript(string scriptName, params object[] args)
        //{
        //    ClientInvokeJsModel js = new ClientInvokeJsModel() { Url = _currentOpenUrl, ScriptName = scriptName, ReqParamList = args };

        //    js.MsgId = Guid.NewGuid().ToString();

        //    if (!_jsCallBackData.ContainsKey(js.MsgId))
        //    {
        //        _jsCallBackData.Add(js.MsgId, js);
        //    }
        //    this.SendMessage(js);
        //    object result = null;
        //    await Task<object>.Run(() =>
        //    {
        //        while (true)
        //        {
        //            if (_jsCallBackData[js.MsgId].IsCompleted)
        //            {
        //                result = _jsCallBackData[js.MsgId];
        //                _jsCallBackData.Remove(js.MsgId); break;
        //            }
        //        }
        //    });

        //    return result;
        //}


        #endregion
    }