WCF心跳判断服务端及客户端是否掉线并实现重链接

时间 2019-11-20

标签 wcf 心跳判断服务客户端是否掉线实现链接繁體版

原文原文链接

本篇文章将经过一个实例实现对WCF中针对服务端以及客户端是否掉线进行判断；若掉线时服务器或客户端又在线时将实现自动重连；将经过WCF的双工知识以及相应的心跳包来实现此功能；服务器

首先了解一下本实例的一个分层架构图；相信了解WCF对这个分层法确定都很了解；其中Client为客户端，Interface为契约层，Service则是实现契约的服务层；架构

接下来咱们将对各层进行一个简单的讲解；方便你们理解实例的实现方式；tcp

首先咱们了解契约层Interface；由于咱们利用WCF中的双工知识，因此此处咱们定义的两个接口，其中ICallback为回调接口；IPushMessage上面定义的回调；咱们发现回调接口上并无定义ServiceContract; 实际上是WCF当一个接口被定义成回调接口时已经默认了；学习

using System.ServiceModel;
namespace Interface
{
    [ServiceContract(SessionMode=SessionMode.Required,CallbackContract=typeof(ICallback))]
    public interface IPushMessage
    {
        [OperationContract(IsOneWay = true)]
        void Login(string UID);

        [OperationContract(IsOneWay = true)]
        void Update(string UID);

        [OperationContract(IsOneWay = true)]
        void Leave(string UID);
    }
}

using System.ServiceModel;
namespace Interface
{
    public interface ICallback
    {
        [OperationContract(IsOneWay = true)]
        void ShowMessage(string msg);
    }
}

接着咱们了解一下实现契约的服务层Service;此处包括实现接口IPushMessage的服务内容，还定义一个类WcfCleint；在PushMessageServer服务内里咱们定义的一个静态成员Dictionary<string,WcfCleint>用于记录咱们客户端上下线的操做；定义的一个lockObje用来锁定每一个操做,在最后咱们还定义的一个定时器用来判断客户端用户是否脱机了；其中方法Update()咱们就实现的双工中的回调；ui

using System.ServiceModel;
using Interface;
namespace Service
{
    public class PushMessageServer:IPushMessage
    {
        static Dictionary<string, WcfCleint> dit_callback = new Dictionary<string, WcfCleint>();

        private static Object lockObje = new Object();

        public void Login(string UID)
        {
            Console.WriteLine("用户:" + UID + "上线");
            lock (lockObje)
            {
                dit_callback.Add(UID, new WcfCleint(OperationContext.Current.GetCallbackChannel<ICallback>(), DateTime.Now));
            }
        }

        public void Update(string UID)
        {
            ICallback callback = OperationContext.Current.GetCallbackChannel<ICallback>();
            Console.WriteLine("用户:" + UID + "心跳更新！");
            lock (lockObje)
            {
                if (dit_callback.ContainsKey(UID))
                {
                    dit_callback.Remove(UID);
                }
                dit_callback.Add(UID, new WcfCleint(OperationContext.Current.GetCallbackChannel<ICallback>(), DateTime.Now));
                callback.ShowMessage(UID);
            }
        }

        public void Leave(string UID)
        {
            Console.WriteLine("用户:" + UID + "退出！");
            lock (lockObje)
            {
                dit_callback.Remove(UID);
            }
        }

        static System.Timers.Timer timer1;
        public static void StartListenClients()
        {
            timer1 = new System.Timers.Timer();
            timer1.Interval = 500;
            timer1.Elapsed += new System.Timers.ElapsedEventHandler(time_EventArgs);
            timer1.Start();
        }

        static void time_EventArgs(object sender, System.Timers.ElapsedEventArgs e)
        {
            lock (lockObje)
            {
                foreach (string key in new List<string>(dit_callback.Keys))
                {
                    if (dit_callback[key].NowdateTime.AddSeconds(5) < DateTime.Now)
                    {
                        dit_callback.Remove(key);
                        Console.WriteLine("脱机用户" + key);
                    }
                }
            }
        }
    }
}

接着咱们简单看一下WcfCleint的代码：this

using Interface;
using System.ServiceModel;
namespace Service
{
    public class WcfCleint
    {
        public DateTime NowdateTime { get; set; }
        public ICallback callbackHandler { get; set; }

        public WcfCleint(ICallback callback, DateTime nowTime)
        {
            this.callbackHandler = callback;
            this.NowdateTime = nowTime;
        }
    }
}

服务端的配置文件信息，此处咱们采用net.tcp方式：spa

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <behaviors>
      <serviceBehaviors>
        <behavior name="exposeExceptionDetail">
          <serviceDebug includeExceptionDetailInFaults="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <services>
      <service name="Service.PushMessageServer"
               behaviorConfiguration="exposeExceptionDetail">
        <endpoint address="net.tcp://127.0.0.1:3721/PushMessageServer"
                  binding="netTcpBinding"
                  contract="Interface.IPushMessage"/>
      </service>
    </services>
  </system.serviceModel>
</configuration>

服务端的运行入口代码，经过一个线程不断的运行：线程

using System.Threading;
using System.ServiceModel.Description;
namespace Service
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(PushMessageServer)))
            {
                host.Open();
                Console.WriteLine("WCF心跳包实现开始监听");
                PushMessageServer.StartListenClients();
                int i = 0;
                while (true)
                {
                    System.Threading.Thread.Sleep(2000);
                    i++;
                }
                Console.Read();
                host.Abort();
                host.Close();
            }
        }
    }
}

接着了解客户端层的状况；首先是一个实现的回调接口的内容类；code

using Interface;
namespace Client
{
    public class CallServer:ICallback
    {
        public void ShowMessage(string msg)
        {
            Console.WriteLine("服务器正在工做中；" + msg);
        }
    }
}

客户端的配置信息以下：server

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="pushmessageserver"
                address="net.tcp://127.0.0.1:3721/PushMessageServer"
                binding="netTcpBinding"
                contract="Interface.IPushMessage"/>
    </client>
  </system.serviceModel>
</configuration>

客户端的运行入口代码以下，它会判断服务器是否掉线，若掉线会试着重连：

using System.ServiceModel;
using Interface;
using System.ServiceModel.Channels;
using System.Threading;
namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            InstanceContext callback = new InstanceContext(new CallServer());
            using (DuplexChannelFactory<IPushMessage> channelFactory = new DuplexChannelFactory<IPushMessage>(callback, "pushmessageserver"))
            {
                IPushMessage proxy = channelFactory.CreateChannel();
                using (proxy as IDisposable)
                {
                    string UID = "踏浪帅";
                    proxy.Login(UID);

                    while (true)
                    {
                        Thread.Sleep(3000);
                        try
                        {
                            proxy.Update(UID);
                        }
                        catch
                        {
                            try
                            {
                                Console.WriteLine("正在重连");
                                proxy = channelFactory.CreateChannel();
                                proxy.Login(UID);
                            }
                            catch
                            {
                                Console.WriteLine("重连异常");
                            }
                        }
                    }
                }
            }
            Console.Read();
        }
    }
}

代码的内容就如上，接着咱们简单看一下运行的效果：

1：首先运行服务端，让其处于监听

2：接着运行客户端，客户端会显示服务器正在工做中以及当前的帐号

3：当客户端上线后，服务端就发现客户端用户，并显示出来，不停的进行判断

4：当咱们把服务端停掉之后，此时服务是不工做的，咱们能够看到客户端就会不停的尝试着重连服务端；

5：当咱们从新把服务端打开之后，服务端会自运发现正在运行的客户端信息；

6：上面咱们从新打开服务端，咱们能够在客户端发现它重链接服务端成功并显示以下：

7：接着咱们将把客户端关闭；咱们会在服务端发现它提示客户端的用户脱机了；

8：此时服务端仍是不停的监听中，咱们再把客户端打开，服务端将会接着显示用户；

实例为本人学习WCF知识所写，其中可能存在不足或错误，欢迎你们指正；如果本文对你有帮助别忘记点右下角帮忙推荐，毕竟有你们的支持才是咱们写做的动力；