js調用本地程序資源-兼容所有瀏覽器

　　

　　在網頁上通過JavaScript調用本地程序，兼容IE8/9/10/11、Opera、Chrome、Safari、Firefox等所有瀏覽器，在做Web開發時經常會遇到需要調用本地的一些exe或者dll程序，比如身份證讀卡器，打印機等設備。

傳統方式通過Activex控件，但這種方式只針對IE瀏覽器，並且在IE11之后Microsoft Edge瀏覽器中，微軟也不在支持Activex控件了。因此想到了利用Websocket以及Http長鏈接方式來實現網頁對本地資源程序的調用。

通過c#創建一個winform的客戶端程序開啟Websocket以及Http請求監聽程序，在js中判斷瀏覽器支持Websocket，則通過Websocket與本地程序通信，如果瀏覽器不支持Websocket（比如IE8/9）則自動采用Http長鏈接實現通信。

支持功能：心跳檢測，斷開重連，客戶端版本檢測，在一個頁面可同時給客戶端發送多個請求任務。每一次SocketCall調用都會生成一個唯一的任務Id，在斷開重連等情況下能保證任務不丟失。

js調用示例

SocketCall(path, sendMsg, function (data) {

                //客戶端返回回調方法
                console.log("返回結果：" + JSON.stringify(data));

            }, function (msg, isHeart) {
                
                //調用消息的輸出，比如心跳檢測，錯誤消息
                console.log(msg);
            });     

 

js代碼-自動識別通信方式

 

/* 
* 本地資源調用封裝
* url:            調用地址 不需要主機和端口，例如：/yb
* data:            輸入參數
* callback:        成功回調函數,函數簽名為  function(data), data參數為服務端返回對象{"Code":1,"Msg":"","Data":null}
* output:        日志輸出函數,函數簽名為  function(msg,isHeart), msg輸出字符串  isHeart是否心跳，重試消息
*/
function SocketCall(url, data, callback, output) {
    //輸入參數json序列號
    if (typeof data == "object" && typeof (data) != null) {
        data = JSON.stringify(data);
    }
    //發送請求
    if ('WebSocket' in window) {
        return new WSocket(url, data, callback, output);
    } else {
        return new HttpSocket(url, data, callback, output);
    }
}

  

js代碼-websocket調用封裝

/* 
* webscoket調用封裝
* url:            調用地址
* data:            輸入參數
* callback:        成功回調函數,函數簽名為  function(data), data參數為服務端返回對象{"Code":1,"Msg":"","Data":null}
* output:        日志輸出函數,函數簽名為  function(msg,isHeart), msg輸出字符串  isHeart是否心跳，重試消息
*/
var WSocket = function (url, data, callback, output) {
    this.url = url;
    this.data = data;
    this.callback = callback;
    this.output = output;
    this.outMsg = function (msg, isHeart) {
        if (!isHeart) isHeart = false;
        if (this.output) {
            this.output(msg, isHeart);
        }
        if (!isHeart) {
            console.log(msg);
        }
    };
    if (this.data == "HeartBeat" || this.data == "TaskIsExist") {
        this.outMsg("發送內容不能是關鍵字：HeartBeat或TaskIsExist");
        return;
    }
    //初始化
    this.taskId = GetTaskId();//任務Id
    this.url = "ws://" + SocketHost + GetUrlQueryString(this.url, this.taskId);//連接地址    
    this.IsComplate = false;//任務是否已完成
    this.lockReconnect = false;//是否鎖定重連
    this.rcTimeoutObj = null;//重連定時器
    this.heartCheck = new WSHeartCheck(this);//心跳檢測對象
    this.webSocket = null;//webSocket鏈接對象
    this.taskIsSend = false;//任務請求是否已發送
    this.IsUpgrade = false;//當前是否版本升級

    this.Open = function () {//連接
        this.webSocket = new WebSocket(this.url);
        this.webSocket.SrcWSocketSelf = this;
        if (!window.WSocketObjs) {
            window.WSocketObjs = new Array();
        }
        window.WSocketObjs.push(this);
        //連接成功建立的回調方法
        this.webSocket.onopen = function (event) {
            this.SrcWSocketSelf.IsUpgrade = false;
            RemoveAlertClientRunMsg();
            //心跳檢測
            this.SrcWSocketSelf.heartCheck.reset().start();
            //發送任務數據
            if (!this.SrcWSocketSelf.taskIsSend) {
                this.SrcWSocketSelf.webSocket.send(this.SrcWSocketSelf.data);
                this.SrcWSocketSelf.taskIsSend = true;
                this.SrcWSocketSelf.outMsg("ws發送任務成功，等待返回...");
            } else {
                //判斷任務是否存在
                this.SrcWSocketSelf.webSocket.send("TaskIsExist");
            }
        };
        //接收到消息的回調方法
        this.webSocket.onmessage = function (event) {
            var resModel = JSON.parse(event.data);
            //處理消息
            if (resModel.Code == 8) {
                this.SrcWSocketSelf.outMsg("ws接收心跳響應：" + event.data, true);
                this.SrcWSocketSelf.heartCheck.reset().start();//重置並開始下一個心跳檢測
            } else if (resModel.Code == 2) {//繼續等待
                this.SrcWSocketSelf.outMsg("重連成功，繼續等待返回...");
            } else if (resModel.Code == 3) {//版本升級等待
                this.SrcWSocketSelf.outMsg("客戶端版本升級中，請等待...");
                this.SrcWSocketSelf.taskIsSend = false;
                this.SrcWSocketSelf.IsUpgrade = true;
                this.SrcWSocketSelf.Reconnect();//啟動重連
            } else if (this.SrcWSocketSelf.callback) {
                this.SrcWSocketSelf.IsComplate = true;
                this.SrcWSocketSelf.Close();
                this.SrcWSocketSelf.callback(resModel);
            } else {
                this.SrcWSocketSelf.IsComplate = true;
                this.SrcWSocketSelf.Close();
                this.SrcWSocketSelf.outMsg("ws接收數據：" + event.data);
            }
        };
        //連接發生錯誤的回調方法
        this.webSocket.onerror = function (event) {
            //啟動應用
            if (this.SrcWSocketSelf.IsUpgrade != true) {
                StartLocalExe();
            }
            //重新鏈接
            this.SrcWSocketSelf.Reconnect();
        };
        //連接關閉的回調方法
        this.webSocket.onclose = function (event) {
            this.SrcWSocketSelf.outMsg("ws連接已關閉", true);
            this.SrcWSocketSelf.heartCheck.reset();//心跳檢測
            this.SrcWSocketSelf.Reconnect();
        };
    };
    this.Open();

    //以下定義公共方法
    this.Reconnect = function () {//重連
        if (this.lockReconnect) {
            return;
        };
        if (this.IsComplate) {
            return;
        }
        var self = this;
        this.lockReconnect = true;
        this.rcTimeoutObj && clearTimeout(this.rcTimeoutObj);
        this.rcTimeoutObj = setTimeout(function () {
            self.lockReconnect = false;
            self.outMsg('ws開始重試...', true);
            self.Open();
        }, 1000);
    };
    this.SendData = function (data) {//發送數據
        if (this.webSocket == null) {
            return "鏈接未初始化！";
        }
        if (this.webSocket.readyState != 1) {
            return "鏈接不是正常狀態";
        }
        this.webSocket.send(data);
        return "";
    };
    this.Close = function (data) {//關閉連接
        if (this.webSocket != null) {
            this.heartCheck.reset();
            this.webSocket.close();
        }
    };
};

//監聽窗口關閉事件，當窗口關閉時，主動去關閉websocket連接或者HttpSocket。
window.onbeforeunload = function () {
    if (window.WSocketObjs) {
        for (var i in window.WSocketObjs) {
            window.WSocketObjs[i].Close();
        }
    }
};

//websocket心跳檢測
var WSHeartCheck = function (wSocket) {
    this.timeout = 8000;//心跳間隔 8秒
    this.timeoutObj = null;
    this.serverTimeoutObj = null;
    this.wSocket = wSocket;

    this.reset = function () {//重置
        clearTimeout(this.timeoutObj);
        clearTimeout(this.serverTimeoutObj);
        return this;
    };

    this.start = function () {//開始心跳
        var self = this;
        this.timeoutObj && clearTimeout(this.timeoutObj);
        this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
        this.timeoutObj = setTimeout(function () {
            //這里發送一個心跳，后端收到后，返回一個心跳消息，onmessage拿到返回的心跳就說明連接正常
            self.wSocket.SendData("HeartBeat");
            self.serverTimeoutObj = setTimeout(function () { // 如果超過5秒還沒重置，說明鏈接斷開了
                self.wSocket.Close();//onclose會執行reconnect
            }, 5000);
        }, this.timeout);
    };
}

 

js代碼-http長鏈接調用封裝

/* 
* http調用封裝
* url:            調用地址
* data:            輸入參數
* callback:        成功回調函數,函數簽名為  function(data), data參數為服務端返回對象{"Code":1,"Msg":"","Data":null}
* output:        日志輸出函數,函數簽名為  function(msg,isHeart), msg輸出字符串  isHeart是否心跳，重試消息
*/
var HttpSocket = function (url, data, callback, output) {
    this.url = url;
    this.data = data;
    this.callback = callback;
    this.output = output;
    this.taskId = GetTaskId();//任務Id
    this.url = "http://" + SocketHost + GetUrlQueryString(this.url, this.taskId);
    this.taskIsSend = false;//任務請求是否已發送
    this.IsComplate = false;//任務是否已完成
    this.lockReconnect = false;//是否鎖定重連
    this.rcTimeoutObj = null;//重連定時器
    this.IsUpgrade = false;//當前是否版本升級
    this.outMsg = function (msg, isHeart) {
        if (!isHeart) isHeart = false;
        if (this.output) {
            this.output(msg, isHeart);
        }
        if (!isHeart) {
            console.log(msg);
        }
    };
    //發送任務請求
    this.Open = function () {
        if (this.taskIsSend) {
            return;
        }
        WAjax.post(this.url, this.data, function (resData, state) {
            //請求成功
            RemoveAlertClientRunMsg();
            state.outMsg("htp發送任務成功，等待返回...");
            state.taskIsSend = true;
            state.IsUpgrade = false;
            if (resData.Code == 2) {//開始獲取任務結果
                state.IsComplate = false;
                state.GetTaskReslut();
            } else if (resData.Code == 3) {//版本升級等待
                state.outMsg("客戶端版本升級中，請等待...");
                state.taskIsSend = false;
                state.IsUpgrade = true;
                //重新發送
                state.Reconnect();
            } else {
                //返回結果
                state.IsComplate = true;
                if (state.callback) {
                    state.callback(resData);
                }
            }
        }, function (err, state) {//ajax調用失敗
            state.outMsg("htp發送任務失敗：" + err, true);
            //重新發送
            state.Reconnect();
        }, this);
    };
    this.Open();

    //重新發送
    this.Reconnect = function () {
        if (this.lockReconnect) {
            return;
        };
        if (this.IsComplate) {
            return;
        }
        var self = this;
        this.lockReconnect = true;
        this.rcTimeoutObj && clearTimeout(this.rcTimeoutObj);
        this.rcTimeoutObj = setTimeout(function () {
            self.lockReconnect = false;
            self.outMsg('htp開始重試...', true);
            self.Open();
        }, 1000);
    };

    //獲取任務結果
    this.GetTaskReslut = function () {
        //地址
        var gUrl = "http://" + SocketHost + "/_getTaskReslut" + GetUrlQueryString("", this.taskId);
        //get請求
        WAjax.get(gUrl, function (resData, state) {
            state.outMsg("htp獲取任務狀態：" + JSON.stringify(resData), true);
            if (resData.Code == 2) {//繼續獲取        
                state.IsComplate = false;
                state.GetTaskReslut();
            } else {//返回結果
                state.IsComplate = true;
                if (state.callback) {
                    state.callback(resData);
                }
            }
        }, function (err, state) {
            state.outMsg("htp獲取任務狀態失敗：" + err, true);//輸出錯誤
            state.GetTaskReslut();//繼續獲取
        }, this);
    }
}

 

//Ajax調用
var WAjax = {
    get: function (url, onSuccess, onError, state) {
        var xhr = new XMLHttpRequest();
        if (window.XMLHttpRequest) {
            xhr = new XMLHttpRequest();
        } else {
            xhr = new ActiveXObject("Microsoft.XMLHTTP");
        }
        xhr.open('GET', url, true);
        xhr.onreadystatechange = function () {
            if (xhr.readyState == 4) {
                if (xhr.status == 200) {
                    //請求成功
                    var model = JSON.parse(xhr.responseText);
                    if (onSuccess) {
                        onSuccess(model, state);
                    }
                } else {
                    if (onError) {
                        onError("http狀態碼" + xhr.status, state);
                    }
                }
            }
        }
        xhr.onerror = function (evt) {
            //啟動應用
            if (state.IsUpgrade != true) {
                StartLocalExe();
            }
            //此處不執行錯誤回調，因為在onreadystatechange里面也會執行
        }
        xhr.send();
    },

    post: function (url, data, onSuccess, onError, state) {
        var xhr = new XMLHttpRequest();
        if (window.XMLHttpRequest) {
            xhr = new XMLHttpRequest();
        } else {
            xhr = new ActiveXObject("Microsoft.XMLHTTP");
        }
        xhr.open('POST', url, true);
        xhr.onreadystatechange = function () {
            if (xhr.readyState == 4) {
                if (xhr.status == 200) {
                    //請求成功
                    var model = JSON.parse(xhr.responseText);
                    if (onSuccess) {
                        onSuccess(model, state);
                    }
                } else {
                    if (onError) {
                        onError("http狀態碼" + xhr.status, state);
                    }
                }
            }
        }
        xhr.onerror = function (evt) {
            //啟動應用
            if (state.IsUpgrade != true) {
                StartLocalExe();
            }
            //此處不執行錯誤回調，因為在onreadystatechange里面也會執行
        }
        xhr.send(data);
    }
}

 

//獲取任務Id
function GetTaskId() {
    var now = new Date();
    var taskId = (now.getMonth() + 1).toString();
    taskId += now.getDate();
    taskId += now.getHours();
    taskId += now.getMinutes();
    taskId += now.getSeconds();
    taskId += now.getMilliseconds();
    taskId += Math.random().toString().substr(3, 5);//3位隨機數
    return taskId;
}

//啟動本地exe
function StartLocalExe() {
    var ifrm = document.getElementById("ifrm_StartLocalExe");
    if (!ifrm) {
        ifrm = document.createElement('iframe');
        ifrm.id = "ifrm_StartLocalExe";
        ifrm.src = "XhyClinicClient://";
        ifrm.width = 0;
        ifrm.height = 0;
        document.body.appendChild(ifrm);
    }
    document.getElementById('ifrm_StartLocalExe').contentWindow.location.reload();

    //var linkTmp = document.createElement('a');
    //linkTmp.href = 'XhyClinicClient://';
    //linkTmp.click();
};

//獲取地址請求參數
function GetUrlQueryString(url, taskId) {
    //參數中添加time 以兼容在Ie9以下瀏覽器中 相同http地址，瀏覽器的緩存不處理問題
    if (url.indexOf("?") > 0) {
        return url + "&taskId=" + taskId + "&clientVer=" + ClientVer + "&time" + new Date().getTime();
    } else {
        return url + "?taskId=" + taskId + "&clientVer=" + ClientVer + "&time" + new Date().getTime();
    }
}

 

客戶端程序

客戶端采用c#，winform實現，采用.netframework4.0版本，支持xp，win7，win10等操作系統。websocket實現采用的是開源項目：websocket-sharp.dll

/// <summary>
    /// WebSocket主類
    /// </summary>
    public class WSMain
    {
        #region 字段

        /// <summary>
        /// 檢測客戶端連接 處理線程
        /// </summary>
        private BackgroundWorker _doWork_checkClient;
        /// <summary>
        /// 檢測線程 信號燈
        /// </summary>
        private AutoResetEvent _doWorkARE = new AutoResetEvent(true);

        private int _heartBeatSecond = 8000;
        /// <summary>
        /// 獲取或設置 心跳檢測時間間隔(單位毫秒)  默認值(8000毫秒)
        /// 此值必須與客戶端設置相同值 最小值1000毫秒
        /// </summary>
        public int HeartBeatSecond
        {
            get { return _heartBeatSecond; }
            set
            {
                if (value < 1000)
                {
                    throw new Exception("心跳檢測時間間隔必須大於等於1秒");
                }
                _heartBeatSecond = value;
            }
        }
        /// <summary>
        /// 服務器是否正在運行
        /// </summary>
        public bool IsRunning { get; private set; }

        /// <summary>
        /// WebSocketServer
        /// </summary>
        private HttpServer _httpServer;
        /// <summary>
        /// WebSocketServer對象
        /// </summary>
        public HttpServer HttpServer
        {
            get
            {
                return _httpServer;
            }
        }

        #endregion

        /// <summary>
        /// 啟動WebSocket
        /// </summary>
        public void Start()
        {
            _httpServer = new HttpServer(CommonInfo.WsPort);
            _httpServer.OnGet += _httpServer_Handler;
            _httpServer.OnPost += _httpServer_Handler;
            foreach (KeyValuePair<string, HandlerModel> item in HandlerManager.Handlers)
            {
                _httpServer.AddWebSocketService<MyWebSocketBehavior>(string.Format("/{0}", item.Key));
            }
            _httpServer.Start();

            //啟動檢測
            IsRunning = true;
            _doWork_checkClient = new BackgroundWorker();
            _doWork_checkClient.DoWork += DoWorkCheckMethod;
            _doWork_checkClient.RunWorkerAsync();
        }

        #region Http請求處理

        /// <summary>
        /// Http請求處理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _httpServer_Handler(object sender, HttpRequestEventArgs e)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(e.Request.Url.AbsolutePath))
                {
                    HttpResponse(e, new WSResModel(ResCode.Err, "請求路徑不存在！"));
                    return;
                }
                string path = e.Request.Url.AbsolutePath.TrimStart('/');
                string taskId = e.Request.QueryString["taskId"];
                string clientVer = e.Request.QueryString["clientVer"];//客戶端版本號
                if (path == "TestConnect")
                {
                    HttpResponse(e, new WSResModel(ResCode.OK));
                    return;
                }
                if (!string.IsNullOrWhiteSpace(clientVer) && CommonInfo.Version != clientVer)
                {
                    HttpResponse(e, new WSResModel(ResCode.ClientAutoUpgrade, string.Format("請將客戶端版本升級至{0}", clientVer)));
                    Program.ExitAndStartAutoUpgrade();
                    return;
                }
                if (string.IsNullOrWhiteSpace(taskId))
                {
                    HttpResponse(e, new WSResModel(ResCode.Err, "請求參數TaskId必須！"));
                    return;
                }
                if (path == "_getTaskReslut")
                {
                    Stopwatch sw = new Stopwatch();
                    sw.Start();
                    GetTaskWaitReslut(taskId, e, sw);
                }
                else
                {
                    BaseHandler handler = HandlerManager.CreateHandler(path);
                    if (handler == null)
                    {
                        HttpResponse(e, new WSResModel(ResCode.Err, string.Format("請求路徑{0}未找到對應Handler", path)));
                        return;
                    }
                    //參數解析
                    string msg = string.Empty;
                    if (e.Request.ContentLength64 > 0)
                    {
                        using (System.IO.StreamReader stream = new System.IO.StreamReader(e.Request.InputStream, Encoding.UTF8))
                        {
                            msg = stream.ReadToEnd();
                        }
                    }
                    //斷開並返回客戶端
                    HttpResponse(e, new WSResModel(ResCode.Wait));
                    //線程繼續處理消息
                    handler.Path = path;
                    handler.TaskId = taskId;
                    handler.ReqIsWebSocket = false;
                    handler.InPara = msg;
                    if (HandlerTaskManager.AddTask(handler))
                    {
                        handler.HandlerTask(msg);
                    }
                }
            }
            catch (Exception ex)
            {
                HttpResponse(e, new WSResModel(ResCode.Err, string.Format("服務器異常:{0}", ex.Message)));
            }
        }

        /// <summary>
        /// 等待並獲取任務結果
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="e"></param>
        private void GetTaskWaitReslut(string taskId, HttpRequestEventArgs e, Stopwatch sw)
        {
            try
            {
                if (sw.ElapsedMilliseconds > HeartBeatSecond)
                {
                    //超過心跳 則返回給客戶端，以便下次繼續請求
                    HttpResponse(e, new WSResModel(ResCode.Wait));
                    return;
                }
                //獲取任務狀態
                WSResModel resModel = HandlerTaskManager.GetTaskReslut(taskId);
                if (resModel != null)
                {
                    HttpResponse(e, resModel);
                }
                else
                {
                    Thread.Sleep(50);
                    GetTaskWaitReslut(taskId, e, sw);
                }
            }
            catch (Exception ex)
            {
                HttpResponse(e, new WSResModel(ResCode.Err, string.Format("服務器內部異常:{0}", ex.Message)));
            }
        }

        /// <summary>
        /// Http響應客戶端
        /// </summary>
        /// <param name="e"></param>
        /// <param name="resMsg"></param>
        private void HttpResponse(HttpRequestEventArgs e, WSResModel resModel)
        {
            try
            {
                string json = CommonLibrary.MyJson.JsonSerializer(resModel);
                byte[] content = System.Text.Encoding.UTF8.GetBytes(json);

                e.Response.StatusCode = (int)HttpStatusCode.OK;
                e.Response.AddHeader("Access-Control-Allow-Origin", "*");//允許跨域訪問
                e.Response.ContentEncoding = Encoding.UTF8;
                e.Response.ContentLength64 = content.Length;
                e.Response.OutputStream.Write(content, 0, content.Length);
                e.Response.OutputStream.Close();
                e.Response.Close();
            }
            catch (Exception ex)
            {
                CommonInfo.Output("Http響應客戶端異常：{0}", ex.Message);
            }
        }

        #endregion

        /// <summary>
        /// 后台線程方法
        /// 主要處理客戶端連接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DoWorkCheckMethod(object sender, DoWorkEventArgs e)
        {
            int timeout = HeartBeatSecond * 3;//連續3次檢測無心跳 則表示客戶端已死掉了
            while (IsRunning)
            {
                try
                {
                    _doWorkARE.Reset();
                    _doWorkARE.WaitOne(HeartBeatSecond);

                    //定時清理任務
                    HandlerTaskManager.ClearTask();

                    foreach (WebSocketServiceHost host in _httpServer.WebSocketServices.Hosts)
                    {
                        List<IWebSocketSession> tempList = host.Sessions.Sessions.ToList();
                        foreach (var item in tempList)
                        {
                            MyWebSocketBehavior handler = item as MyWebSocketBehavior;
                            if (handler != null)
                            {
                                //檢測連接
                                if ((DateTime.Now - handler.LastRecvTime).TotalSeconds > timeout)
                                {
                                    //斷開客戶端連接
                                    CloseClientSocket(handler);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    CommonInfo.Output("檢測連接異常：{0}", ex.Message);
                }
            }
        }

        /// <summary>
        /// 關閉客戶端連接
        /// </summary>
        /// <param name="session"></param>
        public void CloseClientSocket(MyWebSocketBehavior handler)
        {
            try
            {
                handler.Context.WebSocket.Close();
            }
            catch (Exception ex)
            {
                CommonInfo.Output("斷開客戶端異常：{0}", ex.Message);
            }
        }

        /// <summary>
        /// 退出WebSocket
        /// </summary>
        public void Stop()
        {
            //關閉WebScoket
            IsRunning = false;
            _doWorkARE.Set();
            HandlerTaskManager.TaskQueue.Clear();
            _httpServer.Stop(WebSocketSharp.CloseStatusCode.Abnormal, "服務退出");
        }

        #region 單例對象

        private static WSMain _instance;
        /// <summary>
        /// 單例對象
        /// </summary>
        public static WSMain Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new WSMain();
                }
                return _instance;
            }
        }
        #endregion
    }

 

/// <summary>
    /// WebSocket消息處理類
    /// </summary>
    public class MyWebSocketBehavior : WebSocketBehavior
    {
        #region 字段

        /// <summary>
        /// 最后接受數據時間
        /// </summary>
        public DateTime LastRecvTime = DateTime.Now;

        /// <summary>
        /// 任務Id
        /// </summary>
        public string TaskId
        {
            get
            {
                return this.Context.QueryString["taskId"];
            }
        }

        /// <summary>
        /// 客戶端版本號
        /// </summary>
        public string ClientVer
        {
            get
            {
                return this.Context.QueryString["clientVer"];
            }
        }

        /// <summary>
        /// 請求路徑
        /// </summary>
        public string PathName
        {
            get
            {
                return this.Context.RequestUri.AbsolutePath.TrimStart('/');
            }
        }

        /// <summary>
        /// 連接數發生變化事件
        /// </summary>
        public static event Action<MyWebSocketBehavior> ConnectCountChange;

        #endregion

        /// <summary>
        /// 新連接
        /// </summary>
        protected override void OnOpen()
        {
            if (ConnectCountChange != null)
            {
                ConnectCountChange(this);
            }
            if (!string.IsNullOrWhiteSpace(this.ClientVer) && CommonInfo.Version != this.ClientVer)
            {
                SendAndClose(new WSResModel(ResCode.ClientAutoUpgrade, string.Format("請將客戶端版本升級至{0}", this.ClientVer)));
                Program.ExitAndStartAutoUpgrade();
            }
            //CommonInfo.Output("新連接{0}", this.TaskId);
        }

        /// <summary>
        /// 新消息
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
        {
            try
            {
                LastRecvTime = DateTime.Now;
                if (e.IsText)
                {
                    switch (e.Data)
                    {
                        case "HeartBeat":
                            this.Send(CommonLibrary.MyJson.JsonSerializer(new WSResModel(ResCode.HeartBeatRes)));
                            return;
                        case "TaskIsExist":
                            if (HandlerTaskManager.ContainsTask(this.TaskId))
                            {
                                this.Send(CommonLibrary.MyJson.JsonSerializer(new WSResModel(ResCode.Wait)));
                            }
                            else
                            {
                                SendAndClose(new WSResModel(ResCode.Err, "任務不存在！"));
                            }
                            return;
                    }
                }
                BaseHandler handler = HandlerManager.CreateHandler(PathName);
                if (handler == null)
                {
                    SendAndClose(new WSResModel(ResCode.Err, string.Format("請求路徑{0}未找到對應Handler", PathName)));
                    return;
                }
                handler.Path = this.PathName;
                handler.TaskId = this.TaskId;
                handler.ReqIsWebSocket = true;
                handler.InPara = e.Data;
                //添加任務並執行
                if (HandlerTaskManager.AddTask(handler))
                {
                    ThreadPool.QueueUserWorkItem((state) =>
                    {
                        BaseHandler bh = state as BaseHandler;
                        try
                        {
                            bh.HandlerTask(bh.InPara);
                        }
                        catch (Exception ex)
                        {
                            bh.ReturnToClient(new WSResModel(ResCode.Err, ex.Message));
                        }
                    }, handler);
                }
            }
            catch (Exception ex)
            {
                CommonInfo.Output("WS處理消息異常：{0}", ex.Message);
                SendAndClose(new WSResModel(ResCode.Err, string.Format("服務器WS處理消息異常", ex.Message)));
            }
        }

        /// <summary>
        /// 錯誤
        /// </summary>
        /// <param name="e"></param>
        protected override void OnError(WebSocketSharp.ErrorEventArgs e)
        {
            if (e.Exception != null)
            {
                CommonInfo.Output("連接{0}錯誤：{1}", this.TaskId, e.Exception.GetBaseException().Message);
            }
            else
            {
                CommonInfo.Output("連接{0}錯誤：{1}", this.TaskId, e.Message);
            }
        }

        /// <summary>
        /// 關閉
        /// </summary>
        /// <param name="e"></param>
        protected override void OnClose(WebSocketSharp.CloseEventArgs e)
        {
            if (ConnectCountChange != null)
            {
                ConnectCountChange(this);
            }
            //CommonInfo.Output("斷開連接{0}", this.TaskId);
        }

        /// <summary>
        /// 結果返回給客戶端並斷開鏈接
        /// </summary>
        /// <param name="msg"></param>
        public void SendAndClose(WSResModel resModel)
        {
            try
            {
                string json = CommonLibrary.MyJson.JsonSerializer(resModel);
                this.Send(json);
                try
                {
                    this.Context.WebSocket.Close();
                }
                catch (Exception ex) { }
            }
            catch (Exception ex)
            {
                CommonInfo.Output("發送消息異常：{0}", ex.Message);
            }
        }
    }

 

在c#中，自定義消息處理類，只需自己新建一個類，然后繼承至BaseHandler，並實現HandlerTask方法，比如：

/// <summary>
    /// 消息處理器
    /// </summary>
    [HandlerAttribute("yb")]//對應websocket或者http請求路徑，比如：ws:127.0.0.1:3964/yb   或者： http://127.0.0.1:3964/yb
    public class YBHandler : BaseHandler
    {
        /// <summary>
        /// 處理消息
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public override void HandlerTask(string msg)
        {
            //Thread.Sleep(20000);
            FrmTest frm = new FrmTest();
            frm.TopMost = true;
            frm.ShowDialog();
            //在子類中通過調用父類的ReturnToClient方法將消息json對象返回給網頁
            this.ReturnToClient(new WSResModel(ResCode.OK, DateTime.Now.ToString("HH:mm:ss") + "OK：" + msg));
        }
    }

 

結語

源代碼托管於GitHub，供大伙學習參考，項目地址：https://github.com/keguoquan/JsCallExe。感興趣或覺得不錯的望賞個star，不勝感激！

若能順手點個贊，更加感謝！

如有疑問可以QQ咨詢：343798739