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

上一篇文章实现了用windows服务为宿主的SignalR通讯服务端，这一篇将实现用windows服务为宿主的通讯客户端。

废话不多说,放码上来。。。

1、新建一个类库，封装SignalR的客户端相关方法，代码如下:

public class SignalRClient
    {
        //与服务端的交互

        /// <summary>
        /// SignalR通讯管道
        /// </summary>
        private IHubProxy HubProxy { get; set; }
        /// <summary>
        /// SignalR通讯服务端地址
        /// </summary>
        private string ServerURI;
        /// <summary>
        /// SignalR通讯管道名称
        /// </summary>
        private string HubName;
        /// <summary>
        /// 当前客户端
        /// </summary>
        private ClientInfo Client;
        private Logger Log = new Logger(LogName.Signalr_Client.ToString());
        /// <summary>
        /// 错误信息备注
        /// </summary>
        private string ErrMsgRemark = "";
        private JsonSerializerSettings JsonSetting;

        public SignalRClient(string url,string port,string hubName)
        {
            //获取到客户端传来的客户端信息
            JsonSetting = new JsonSerializerSettings();
            JsonSetting.NullValueHandling = NullValueHandling.Ignore;
            this.HubName = hubName;
            this.ServerURI = "http://" + url + ":" + port + "/signalr";
        }
        private HubConnection SrConnection { get; set; }
     
        private void RegisterHunFun()
        {
            //定义客户端开机设置
            ErrMsgRemark = "注册Sr通讯管道客户端函数异常!";
            try
            {
                HubProxy.On(ClientHubFunName.TestClient.ToString(), () =>
                {
                    SrClientHandl.TestClient();
                });
                HubProxy.On<ClientInfo>(ClientHubFunName.BootSetting.ToString(), (ClientInfo client) =>
                 {
                     SrClientHandl.BootSetting(client);
                 });
                HubProxy.On<ClientInfo>(ClientHubFunName.ShutdownSetting.ToString(), (ClientInfo client) =>
                {
                    SrClientHandl.ShutdownSetting(client);
                });
                HubProxy.On<ClientInfo>(ClientHubFunName.GetFlowInfo.ToString(), (ClientInfo client) =>
                {
                    SrClientHandl.GetFlowInfo(client);
                });
                HubProxy.On<ClientInfo>(ClientHubFunName.LogTrans.ToString(), (ClientInfo client) =>
                {
                    SrClientHandl.LogTrans(client);
                });
                HubProxy.On<ClientInfo>(ClientHubFunName.PerfectClientAttribute.ToString(), (ClientInfo client) =>
                {
                    this.Client = client;
                });
            }
            catch (Exception ea)
            {
                Log.Error(ErrMsgRemark, ea);
                throw ea;
            }
        }

        private ClientInfo GetCurrentClient()
        {
            Client = new ClientInfo();
            Client.ClientId = "1111"; 
            return Client;
        }
        //客户端连接
        public async void ConnectAsync() //
        { 
            Log.Info("进入方法Connect，HubName:" + HubName);
            try
            {

                //传给服务端本机信息
                string clientJson = JsonConvert.SerializeObject(GetCurrentClient(), JsonSetting);
                Log.Info("进入方法Connect，传输的客户端json:" + clientJson);         
                var querystringData = new Dictionary<string, string>();
                querystringData.Add("ClientJson", clientJson);
                SrConnection = new HubConnection(ServerURI, querystringData);
    
                SrConnection.Closed += Connection_Closed;
                HubProxy = SrConnection.CreateHubProxy(this.HubName);
    
                Log.Info("进入方法Connect1");
                RegisterHunFun();
                try
                {
                    await SrConnection.Start();
                }
                catch (Exception ea)
                {
                    Log.Error("开启SR链接异常!", ea);
                }
             
                //调用服务端方法
                Log.Info("调用服务端方法SendTest");
                await HubProxy.Invoke("SendTest", "测试");
                Log.Info("链接服务端完毕");
            }
            catch (Exception ea)
            {
                /*这里异常会有一个隐性问题,如客户端未启动起来就悲剧了
                 最好办法是加一个定时服务,检测与服务端通信是否打开,未打开就再次开启链接
                 */
                Log.Error(ea);
            }

        }
        //客户端关闭事件
        private void Connection_Closed()
        {
            //通知服务端下线

            if (SrConnection != null)
            {
                SrConnection.Stop();
                SrConnection.Dispose();
            }
        }
    }

上面SrClientHandl类就是封装RegisterHunFun方法里调用的方法，因为有具体工作的相关代码，这里就不上代码了

2、新建windows服务作为客户SignalR宿主，具体代码如下:

  string srUrl = SignalRContext.Current.ServerIpAddress;
                string srPort = SignalRContext.Current.ServerPort;
                string srHub = SignalRContext.Current.HubName;
                log.Info("srUrl:" + srUrl + ",srPort:" + srPort + ",srHub:" + srHub);
                SignalRClient srClient = new SignalRClient(srUrl, srPort, srHub);
                log.Info("开始连接服务端");
                srClient.ConnectAsync();
                log.Info("连接服务端成功");

3、再补充下,客户端调用服务端方法还是服务端调用客户端开放的方法，双方都可以得到对方方法的返回值的。

这是我服务端的方法:

 //测试数据传输方法
        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;
        }

这是我客户端调用服务端方法的片段:

  await SrConnection.Start();//开启链接
                //调用服务端方法
                Log.Info("调用服务端方法SendTest");
                ClientInfo cl = await SrClientHandl.InvokeServerFunAsync<ClientInfo>(ServerHubFunName.SendTest, HubProxy, new object[] { "test" });
                Log.Info("得到服务端返回的clientinfo:" + JsonConvert.SerializeObject(cl, JsonSetting));

SrClientHandl.InvokeServerFunAsync方法是我封装的一个客户端调用服务端异步方法，代码如下

  //异步执行有返回值的服务端方法 
        public async static Task<T> InvokeServerFunAsync<T>(ServerHubFunName fun, IHubProxy hub, params object[] args)
        {
            T result = await hub.Invoke<T>(fun.ToString(), args);
            return result;
        }

这是日志效果:

 

暂时还不知道怎么查看当前的SignalR使用的哪种通讯方式，因为客户端不是浏览器，应该不是websocket，如果是长连接不知道实际效率怎么样。。。 有SignalR经验丰富的小伙伴可以和我互动下，一起加油！

至此一切ok了。。。。

安利一下微软提供的Signalr相关页面，有兴趣的可以看下:

https://www.asp.net/signalr/overview/getting-started/introduction-to-signalr