在Visual Studio 2019上使用C# 创建用于webstock的windows服务 实现一键打包安装自启动

||–查看的码友,在不麻烦的情况,如果文章有用,烦请点个赞.如果没用可以留言讨论哦–||

本人是主要是做PHP开发, 在做Windows的WebStock服务的过程中 借鉴了很多文章 踩了无数的坑 最终完成 代码部分大多是从网上Copy而来 但是具体是从哪篇文章找到的 具体已经记得不太清楚了 不过在此感谢各位大大的分享…

整套代码下载链接：https://download.csdn.net/download/x1a0x0/12300456

以下 将一步步介绍使用C# 在VS2019平台 从开始创建服务 到写入WebStock 直到最后打包完成 并生成安装文件 并设置自启动的详细步骤
1：创建C# windows服务(基于.NET Framework) PS:第一个坑 我第一次选择了(基于.NET Core)

2:设置项目名称 选择项目位置 与相关框架

3：设置服务名称 服务属性 开机启动
右键->添加安装程序->选择serviceInstaller1->右下键 设置ServiceName服务名称、DisplayName服务通用名、Description服务描述、StartType服务启动类型-Automatic(自动)，可用类型分别为Automatic（自动）、Manual（手动）、Disabled（禁用）。
<<此步骤不确定是否必须>>
继续选择->选择左上serviceProcessInstaller1->设置Account账户类型为LocalSystem（系统服务）

4:创建WebStock代码 基本都是网上在各位博客下一点点拼凑出来的 没有封装。
先贴部分图片代码 最后贴上全部代码

5：代码完成后，因为是服务程序,可能会无法执行。 可以使用命令 installutil尝试 或者继续下面的打包流程。 打包流程:在解决方案处右键->添加->新建项目->选择Setup Project.
PS：2019安装包内不再提供打包项,需手动安装
下载地址：https://visualstudioclient.gallerycdn.vsassets.io/extensions/visualstudioclient/microsoftvisualstudio2017installerprojects/0.9.6/1581535947082/InstallerProjects.vsix
下载完成后双击安装后再创建项目处可见.

6:打包程序设置 这一步比较多的操作 但其实也没有多繁琐
1)左侧->Application Folder右键->Add->项目输出->选择项目->确定.
2)右侧项目列表->选择当前的安装项目 右键->View->自定义操作
3)左侧->Install,Commit,Rollback,Uninstall 4项依次点击右键->添加自定义操作->双击弹窗出的 Application Folder->选择主输出->确定.






7:自启动
此时 生成项目 就可以生成安装包进行安装服务了。但当前服务不能自启动。还需要在服务项目中变形安装完成后的代码.
选择我们的项目->右键生成出的项目安装cs文件->查看代码->写入如下代码.

8:生成安装文件 安装
右侧菜单->安装项目->右键->生成.
在项目目录中可以找到当前项目安装的iso文件与exe文件.
安装完成后 服务自动运行.

9:创建一个HTML 简易的Js代码尝试连接WebStock。

10：至此全部完成.以下是程序代码.
C#服务代码:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.ServiceProcess;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace MyWebStockService
{
    public partial class Service1 : ServiceBase
    {
        static List<Socket> Sockets = new List<Socket>();
        static Thread t;
        static Thread th;
        public Service1()
        {
            InitializeComponent();
        }
        //服务开启执行代码
        protected override void OnStart(string[] args)
        {
            
            // 自定义一个端口
            int port = 61212; 
            // 创建一个WebStock服务
            IPEndPoint localEP = new IPEndPoint(IPAddress.Any, port);
            Socket listener = new Socket(localEP.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            //由于服务需要快速启动完成 不然有可能会超时无响应 所以选择创建线程来执行
            th = new Thread(new ThreadStart(() => CreateAccept(listener, localEP)));
            th.IsBackground = true;
            th.Start();
        }
        //关闭服务执行代码
        protected override void OnStop()
        {
            //关闭相关线程
            if (t != null && t.ThreadState == System.Threading.ThreadState.Running)
                t.Abort();
            if (th != null && th.ThreadState == System.Threading.ThreadState.Running)
                th.Abort();
        }

        /// <summary>
        /// 接受WebStock的连接
        /// </summary>
        /// <param name="listener">Stock</param>
        /// <param name="localEP">连接信息</param>
        /// <returns></returns>
        public static void CreateAccept(Socket listener, IPEndPoint localEP)
        {
            listener.Bind(localEP);
            listener.Listen(10);
            while (true)
            {
                //接受一个连接
                Socket sc = listener.Accept();

                //添加到缓存
                Sockets.Add(sc);

                //创建Socket多线程,以保证多用户连接, 去执行获取数据的动作,与客户端通信 
                t = new Thread(new ThreadStart(() => ReceiveData(sc)));
                t.IsBackground = true;
                t.Start();
            }
        }
        /// <summary>
        /// Stock的数据交互
        /// </summary>
        /// <param name="sc">当前的连接</param>
        /// <returns></returns>
        public static void ReceiveData(Socket sc)
        {
            byte[] buffer = new byte[1024];
            //握手
            int length = sc.Receive(buffer);//接受客户端握手信息
            sc.Send(PackHandShakeData(GetSecKeyAccetp(buffer, length))); while (true)
            {
                //接受客户端数据
                length = sc.Receive(buffer);
                string clientMsg = AnalyticData(buffer, length);
                //发送数据
                string sendMsg = "服务端返回信息:" + clientMsg;
                sc.Send(PackData(sendMsg));
            }
        }
        /// <summary>
        /// 打包握手信息
        /// </summary>
        /// <param name="secKeyAccept">Sec-WebSocket-Accept</param>
        /// <returns>数据包</returns>
        private static byte[] PackHandShakeData(string secKeyAccept)
        {
            var responseBuilder = new StringBuilder();
            responseBuilder.Append("HTTP/1.1 101 Switching Protocols" + Environment.NewLine);
            responseBuilder.Append("Upgrade: websocket" + Environment.NewLine);
            responseBuilder.Append("Connection: Upgrade" + Environment.NewLine);
            responseBuilder.Append("Sec-WebSocket-Accept: " + secKeyAccept + Environment.NewLine + Environment.NewLine);
            //如果把上一行换成下面两行，才是thewebsocketprotocol-17协议，但居然握手不成功，目前仍没弄明白！
            //responseBuilder.Append("Sec-WebSocket-Accept: " + secKeyAccept + Environment.NewLine);
            //responseBuilder.Append("Sec-WebSocket-Protocol: chat" + Environment.NewLine);

            return Encoding.UTF8.GetBytes(responseBuilder.ToString());
        }

        /// <summary>
        /// 生成Sec-WebSocket-Accept
        /// </summary>
        /// <param name="handShakeText">客户端握手信息</param>
        /// <returns>Sec-WebSocket-Accept</returns>
        private static string GetSecKeyAccetp(byte[] handShakeBytes, int bytesLength)
        {
            string handShakeText = Encoding.UTF8.GetString(handShakeBytes, 0, bytesLength);
            string key = string.Empty;
            Regex r = new Regex(@"Sec\-WebSocket\-Key:(.*?)\r\n");
            Match m = r.Match(handShakeText);
            if (m.Groups.Count != 0)
            {
                key = Regex.Replace(m.Value, @"Sec\-WebSocket\-Key:(.*?)\r\n", "$1").Trim();
            }
            byte[] encryptionString = SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
            return Convert.ToBase64String(encryptionString);
        }

        /// <summary>
        /// 解析客户端数据包
        /// </summary>
        /// <param name="recBytes">服务器接收的数据包</param>
        /// <param name="recByteLength">有效数据长度</param>
        /// <returns></returns>
        private static string AnalyticData(byte[] recBytes, int recByteLength)
        {
            if (recByteLength < 2) { return string.Empty; }

            bool fin = (recBytes[0] & 0x80) == 0x80; // 1bit，1表示最后一帧  
            if (!fin)
            {
                return string.Empty;// 超过一帧暂不处理 
            }

            bool mask_flag = (recBytes[1] & 0x80) == 0x80; // 是否包含掩码  
            if (!mask_flag)
            {
                return string.Empty;// 不包含掩码的暂不处理
            }

            int payload_len = recBytes[1] & 0x7F; // 数据长度  

            byte[] masks = new byte[4];
            byte[] payload_data;

            if (payload_len == 126)
            {
                Array.Copy(recBytes, 4, masks, 0, 4);
                payload_len = (UInt16)(recBytes[2] << 8 | recBytes[3]);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 8, payload_data, 0, payload_len);

            }
            else if (payload_len == 127)
            {
                Array.Copy(recBytes, 10, masks, 0, 4);
                byte[] uInt64Bytes = new byte[8];
                for (int i = 0; i < 8; i++)
                {
                    uInt64Bytes[i] = recBytes[9 - i];
                }
                UInt64 len = BitConverter.ToUInt64(uInt64Bytes, 0);

                payload_data = new byte[len];
                for (UInt64 i = 0; i < len; i++)
                {
                    payload_data[i] = recBytes[i + 14];
                }
            }
            else
            {
                Array.Copy(recBytes, 2, masks, 0, 4);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 6, payload_data, 0, payload_len);

            }

            for (var i = 0; i < payload_len; i++)
            {
                payload_data[i] = (byte)(payload_data[i] ^ masks[i % 4]);
            }

            return Encoding.UTF8.GetString(payload_data);
        }


        /// <summary>
        /// 打包服务器数据
        /// </summary>
        /// <param name="message">数据</param>
        /// <returns>数据包</returns>
        private static byte[] PackData(string message)
        {
            byte[] contentBytes = null;
            byte[] temp = Encoding.UTF8.GetBytes(message);

            if (temp.Length < 126)
            {
                contentBytes = new byte[temp.Length + 2];
                contentBytes[0] = 0x81;
                contentBytes[1] = (byte)temp.Length;
                Array.Copy(temp, 0, contentBytes, 2, temp.Length);
            }
            else if (temp.Length < 0xFFFF)
            {
            	//开始使用这种方法时候超过126字节传输失败 使用第二种后可以 后第一种也可以了
                /*
                contentBytes = new byte[temp.Length + 4];
                contentBytes[0] = 0x81;
                contentBytes[1] = 126;
                contentBytes[2] = (byte)(temp.Length & 0xFF);
                contentBytes[3] = (byte)(temp.Length >> 8 & 0xFF);
                Array.Copy(temp, 0, contentBytes, 4, temp.Length);
                */
                contentBytes = new byte[temp.Length + 4];
                contentBytes[0] = 0x81;
                contentBytes[1] = 126;
                contentBytes[2] = (byte)(temp.Length & 0xFF);
                contentBytes[3] = (byte)(temp.Length >> 8 & 0xFF);
                Array.Copy(temp, 0, contentBytes, 4, temp.Length);
            }
            else
            {
                //未测试是否可行  
                contentBytes = new byte[temp.Length + 10];
                contentBytes[0] = 0x81;
                contentBytes[1] = 127;
                contentBytes[2] = 0;
                contentBytes[3] = 0;
                contentBytes[4] = 0;
                contentBytes[5] = 0;
                contentBytes[6] = (byte)(temp.Length >> 24);
                contentBytes[7] = (byte)(temp.Length >> 16);
                contentBytes[8] = (byte)(temp.Length >> 8);
                contentBytes[9] = (byte)(temp.Length & 0xFF);
                Array.Copy(temp, 0, contentBytes, 10, temp.Length); 
            }

            return contentBytes;
        }
    }
}

C#自启动代码:

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration.Install;
using System.Linq;
using System.ServiceProcess;

namespace MyWebStockService
{
    [RunInstaller(true)]
    public partial class ProjectInstaller : System.Configuration.Install.Installer
    {
        public ProjectInstaller()
        {
            InitializeComponent();
        }
        //项目安装完成后执行
        public override void Commit(IDictionary savedState)
        {
            base.Commit(savedState);
            //声明服务 变量为: 通用名 
            ServiceController sc = new ServiceController("我的WebStock服务");
            if (sc.Status.Equals(ServiceControllerStatus.Stopped))
            {
                sc.Start();
            }
        }
    }
}

HTML JS代码:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title></title>
    <script type="text/javascript">
        var ws;
        function ToggleConnectionClicked() {
            try {
                var SOCKECT_ADDR = "ws://127.0.0.1:61212/chat";
                ws = new WebSocket(SOCKECT_ADDR);	
                ws.onopen = function (event) { 
					alert("已经与服务器建立了连接\r\n当前连接状态：" + this.readyState); 
                	ws.send("success");
				};
                ws.onmessage = function (event) { alert("接收到服务器发送的数据：\r\n" + event.data); };
                ws.onclose = function (event) { alert("已经与服务器断开连接\r\n当前连接状态：" + this.readyState); };
                ws.onerror = function (event) {
					alert("WebSocket异常！" + event.toString());
				};
            } catch (ex) {
                alert(ex.message);
            }
        };
 
        function SendData() {
            try {
                ws.send("success");
            } catch (ex) {
                alert(ex.message);
            }
        };
 
        function seestate() {
            alert(ws.readyState);
        }
       
    </script>
</head>
<body>
    <button id='ToggleConnection1' type="button" onClick='ToggleConnectionClicked();'>
        连接服务器</button><br />
    <br />
    <button id='ToggleConnection2' type="button" onClick='SendData();'>
        发送我的名字：beston</button><br />
    <br />
    <button id='ToggleConnection3' type="button" onClick='seestate();'>
        查看状态</button><br />
    <br />
</body>
</html>