使用windows服务、SignalR实现双工通讯之服务端篇

最近工作需要客户端和服务端实现双工通讯，但是客户端不能是网页、窗体。想到了用wcf实现，但是wcf需要了解的东西较多，以前没有使用过，而且时间比较赶最终想到了SignalR。

科室SignalR网上的资料都是基于客户端是网页，几乎没有客户端服务端都为windows服务的博客和说明文档。通过自己一番尝试特将成果写出来,方便以后自己查阅和大家参考；

 

SignalR是微软提供的一个可以双工通讯的框架(我是这么认为),他最牛逼之处在于可以用最少的代码实现我们以前难以实现的服务端主动推送客户端。

其他的说明可以网上搜索一大堆了，不在此处再做说明。

本文主要介绍服务端和客户端均通过windows服务实现双工通讯；

1、首先新建一个类库,该类库用于实现SignalR服务端的封装；

2、使用Nuget下载所依赖的SignalR相关类库，下面的图是我Nuget上下载的库

 

 

 

感觉还是有蛮多库的,下了几个语言包。。。

3、新建一个SignalRService实现类,代码如下:

public class SignalRService : ThreadSafeLazyBaseSingleton<SignalRService>
    {

        /*SignalR服务端
         所需:1、开放的端口号,读取xml实现
              2、客户端实体(用于识别客户端),引用Model层 
              3、自定义SignalR.Hub通讯管道,重写开始连接、关闭连接事件 编写注册方法记录当前在线客户端
         */
        private Logger log = new Logger(LogName.Signalr_Server.ToString());

        private IDisposable SignalR { get; set; }
        //从配置文件读取路径和端口
        private string ServerUrl { get
            {
                return "http://" + SignalRContext.Current.ServerIpAddress + ":" + SignalRContext.Current.ServerPort + "/signalr";
            } }

        public List<ClientInfo> LstClients { get; internal set; }

        public SignalRService() {
            LstClients = new List<ClientInfo>();
        }
        /// <summary>
        /// 启动SignalR通讯服务  
        /// </summary>
        public void StartServer()
        {
            try
            {                
                log.Info("开始启动,url:" + ServerUrl);                
                SignalR = WebApp.Start<Startup>(ServerUrl);
                log.Info("启动成功");
            }
            catch (Exception ea)
            { 
                log.Error("启动通讯服务失败!",ea);
                throw new Exception("启动通讯服务失败!" + ea.Message);
            }
        }

        public void Dispose()
        {
            if (SignalR != null)
            {
                SignalR.Dispose();
            }
        }
     
        class Startup
        {
            private Logger log = new Logger(LogName.Signalr_Server.ToString());
            public void Configuration(IAppBuilder app)
            {
                try
                {
                    log.Info("进入Configuration");
                    var hubConfiguration = new HubConfiguration
                    {
                        EnableDetailedErrors = true     //允许抛出异常明细信息            
                    };
                    
                    app.UseCors(CorsOptions.AllowAll);
                    log.Info("执行完UseCors");
                    app.RunSignalR(hubConfiguration);
                    app.MapSignalR();
                    log.Info("执行完MapSignalR");
                 
                }
                catch (Exception ea)
                {
                    log.Error("启动通讯服务异常:" + ea.Message);
                }
            }
        }
    }

 

4、继承Hub类(官网称为集线器类),Hub类可以理解为SignalR服务端提供给客户端的通讯管道(我是这么理解的，欢迎大神纠正)。这个类有3个比较关键的事件:

OnConnected、  //有客户端连接时候触发

OnDisconnected、 //客户端释放资源时候触发

OnReconnected、 //客户端断开连接后又重新连接时触发

 基于上面的事件实现服务端的相关逻辑。继承Hub类后,除了重写上面事件外，还可以新增方法。这种新增的方法可以理解为服务端提供给客户端远程调用的方法，如何调用在客户端说明时会写。下面是我继承的Hub类:

 [HubName("CustomHub")]
    public class CustomHub: Hub
    {
        private JsonSerializerSettings JsonSetting;
        private Logger Log = new Logger(LogName.Signalr_Server.ToString());
        private DbUtility Db = new DbUtility(SignalRContext.Current.DbConn, DbProviderType.SqlServer);
        #region 重写事件
        //客户端通道连接时触发
        public override Task OnConnected()
        {
            Log.Info("进入OnConnected方法");
            if (SignalRService.Current.LstClients == null)
                SignalRService.Current.LstClients = new List<ClientInfo>();
        
            JsonSetting = new JsonSerializerSettings();
            JsonSetting.NullValueHandling = NullValueHandling.Ignore;
            string queryString = Context.QueryString["ClientJson"].ToString();
            ClientInfo client = JsonConvert.DeserializeObject<ClientInfo>(queryString, JsonSetting);
            Log.Info("接收客户端的client:" + queryString);
          
            //获取到客户端传来的客户端信息
            lock (SignalRService.Current.LstClients)
            {
                if (SignalRService.Current.LstClients.Exists(p => p.ConnId == Context.ConnectionId))
                {//如果服务端已存在此连接(理论上不存在),从现有集合移除再添加
                    Log.Info("开始调用客户端测试方法!");
                    SignalRService.Current.LstClients.RemoveAll(p => p.ConnId == Context.ConnectionId);
                    Log.Info("客户端测试方法调用完毕!");
                }
                else
                {//从数据库得到客户端信息并添加到集合中
          
                    if (SignalRContext.Current.IsDebug)
                    {//如果为debug模式调用客户端的测试方法
                        Log.Info("服务端开始调用客户端方法TestClient");
                        Clients.Client(Context.ConnectionId).TestClient();
                    }
                    else
                    {
                        Dictionary<string, object> input = new Dictionary<string, object>();
                        input.Add("clientid", client.ClientId);
                        List<ClientInfo> lst = ServerHandl.Current.GetClinetInfo(input);
                        if (lst == null || lst.Count == 0)
                        {//如果数据库没有此机器记录..
                            Log.Error("数据库没有机器id[" + client.ClientId + "]的建档记录,客户端机器链接失败!");
                        }
                        else
                        {
                            SignalRService.Current.LstClients.Add(lst[0]);
                            lst[0].ConnId = Context.ConnectionId;
                            lst[0].TransTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            lst[0].TransFlag = 1;
                            //保存到数据库
                            SrServerHandl.Current.SaveLoginClientInfo(lst[0]);
                            //将数据库的记录返回给客户端
                            Clients.Client(Context.ConnectionId).PerfectClientAttribute(lst[0]);
                        }
                    }
                }
            }
            
            return base.OnConnected();
        }
        //客户端通道断开连接时触发
        public override Task OnDisconnected(bool stopCalled)
        {
            return base.OnDisconnected(stopCalled);
        }
        //客户端离线后重新连接时触发
        public override Task OnReconnected()
        {
            return base.OnReconnected();
        }
        #endregion

        //测试数据传输方法
        public ClientInfo SendTest(string name)
        {
            Log.Info("客户端执行服务端方法,参数name:" + name);
            Log.Info(" Context.ConnectionId:" + Context.ConnectionId);
            ClientInfo info = new ClientInfo();
            info.ClientName = name;
            info.ConnId = Context.ConnectionId;
            return info;
        }
    
    }

5、新建一个服务端处理类，我是用来存储先关数据用

public class SrServerHandl: ThreadSafeLazyBaseSingleton<SrServerHandl>
    {
        private DbUtility Db = new DbUtility(SignalRContext.Current.DbConn, DbProviderType.SqlServer);

        public SrServerHandl()
        {
        }
        /// <summary>
        /// 保存客户端登录信息
        /// </summary>
        /// <param name="client"></param>
        public void SaveLoginClientInfo(ClientInfo client)
        {
            //保存到数据库
            List<ParameterEx> ps = new List<ParameterEx>();
            ps.Add(DbUtility.NewSqlStringParameters("connid", client.ConnId, Type.GetType("System.String")));
            ps.Add(DbUtility.NewSqlStringParameters("transtime", DateTime.Now, Type.GetType("System.DateTime")));
            ps.Add(DbUtility.NewSqlStringParameters("transflag", 1, Type.GetType("System.Int32")));
            ParameterEx keyParme = DbUtility.NewSqlStringParameters("clientid", client.ClientId, Type.GetType("System.String"));
            string sql = DbUtility.CreateUpdateSqlString(SqlServerManager.Table_client_info, ps, keyParme);
            Db.ExecuteNonQuery(sql, null);
        }
    }

6、新建windows服务，引用SignalR类库并调用相关方法

 public partial class SignalRService : ServiceBase
    {
        public SignalRService()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            //开始启动服务
            SignalRService.Current.StartServer();
        }

        protected override void OnStop()
        {
            //释放服务
            SignalRService.Current.Dispose();
        }
    }