WCF的回调操作

妖狐艹你老母 2021-09-18 08:28 348阅读 0赞

回调操作在实际系统中应用的非常广泛，该机制使得服务端可以回调客户端操作，而不需要在客户端实现、寄宿新的服务契约。

回调操作必须使用支持双向通信的绑定如NetTcpBinding、NetNamedPipeBinding、WSDualHttpBinding。

**双程操作实例**

下面给出一个双程操作的示例，考虑这要的需求，系统的客户端需要每隔一段时间向服务端发送消息，以通知服务端客户端运行正常。一旦这要的消息终端，服务端将立刻采取相应的措施，如通知系统支持人员等。这样的需求在大型系统中非常常见，一般称呼这样的通知为“心跳”，表示该消息反应了客户端的健康状态。

**1、定义服务契约**

定义服务契约（Service Contract）包括：

回调契约：IheartbeatCallback.cs（心跳频率回调操作）。

服务契约：IheartbeatService.cs（心跳服务契约）。

回调契约属于服务契约的一部分，在WCF中使用ServiceContract的CallbackContract属性可以定义一个服务契约。

**1.1 定义回调契约**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    
    namespace WCF.Third.Contract
    {
        /// <summary>
        /// 回调契约
        /// </summary>
        public interface IheartbeatCallback
        {
            /// <summary>
            /// 回调操作，调整心跳频率
            /// </summary>
            /// <param name="seconds">新的频率</param>
            [OperationContract(IsOneWay=true)]
            void UpdateInterval(int seconds);
        }
    }

**1.2 定义服务契约**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    
    namespace WCF.Third.Contract
    {
        /// <summary>
        /// 心跳服务契约
        /// </summary>
        [ServiceContract(CallbackContract=typeof(IheartbeatCallback))]
        public interface IheartbeatService
        {
            [OperationContract]
            void Heartbeat();
        }
    }

**2、创建服务**

创建HeartbeatService.cs类，实现IheartbeatService服务契约接口。

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    using WCF.Third.Contract;
    
    namespace WCF.Third.Service
    {
        /// <summary>
        /// 心跳服务
        /// </summary>
        [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
        public class HeartbeatService:IheartbeatService
        {
            private bool _highLoad = false;      //是否处于高负荷状态
            private bool _changed = false;       //状态是否已经改变
            //不同负荷下的心跳周期
            private int _highloadInterval = 5;   //周期是5
            private int _lowloadInterval = 2;    //周期是2
    
            //设置负荷状态
            public bool HighLoad
            {
                set 
                {
                    lock (this)    //确定单线程访问状态
                    {
                        if (_highLoad != value)
                        { 
                            //调整状态
                            _changed = true;
                            _highLoad = value;
                            Console.WriteLine("HighLoad已经被设置为：{0}", value);
                        }
                    }
                }
            }
    
            /// <summary>
            /// 实现心跳契约
            /// </summary>
            public void Heartbeat()
            {
                //如果符合已经更改，则回调客户端，更新心跳频率
                if (_changed)
                {
                    IheartbeatCallback callback = OperationContext.Current.GetCallbackChannel<IheartbeatCallback>();
                    callback.UpdateInterval(_highLoad ? _highloadInterval : _lowloadInterval);
                }
                Console.WriteLine("{0}收到心跳", DateTime.Now.ToString());
            }
    
        }
    }

**3、实现服务寄宿**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Description;
    using WCF.Third.Service;
    using WCF.Third.Contract;
    
    namespace WCF.Third.Host
    {
        class Program
        {
            private const string serviceAddressUrl = "net.pipe://localhost/HeartbeatService";              //服务地址
            private const string serviceMetadataUrl = "net.pipe://localhost/HeartbeatService/metadata";    //元数据发布的源地址
    
            static void Main(string[] args)
            {
                try
                {
                    //为了能访问服务对象，这里手动创建服务对象并以该对象创建寄主对象
                    HeartbeatService instance = new HeartbeatService();
                    using (ServiceHost host = new ServiceHost(instance))
                    {
                        //添加一个终结点
                        Uri address = new Uri(serviceAddressUrl);       //地址
                        Binding binding = new NetNamedPipeBinding();    //绑定
                        Type serviceType = typeof(IheartbeatService);   //契约
                        host.AddServiceEndpoint(serviceType, binding, address);
    
                        host.Opened += delegate
                        {
                            Console.WriteLine("服务已经启动！");
                        };
                        host.Open();
    
                        while (true)
                        {
                            char command = Convert.ToChar(Console.Read());
                            //通过ServiceHost的SingletonInstance属性来获取寄宿实例
                            HeartbeatService service = (HeartbeatService)host.SingletonInstance;
                            switch (command)
                            { 
                                case 'q':   //输入q表示退出程序
                                    return;
                                case 'h':   //输入h表示切换到高负荷
                                    { 
                                        
                                        if (service != null)
                                        {
                                            service.HighLoad = true;
                                        }
                                        break;
                                    }
                                case 'l':   //输入l表示切换到底负荷
                                    {
                                        if (service != null)
                                        {
                                            service.HighLoad = false;
                                        }
                                        break;
                                    }
                                default:
                                    break;
                            }
                        }
    
                    }
                }
                catch (Exception ex)    //捕捉异常
                {
                    Console.WriteLine(ex.ToString());
                    Console.Read();
                }
            }
        }
    }

**4、创建客户端调试服务**

双程操作的客户端需要公开回调终结点以供服务端进行回调。为了方便双程操作的客户端编程，WCF提供了DuplexClientBase<T>类型。客户端初始化DuplexClientBase<T>代理对象时，需要提供带有回调对象的实例上下文对象。代理会围绕回调上下文创建一个终结点，回调终结点会使用和服务端相同的绑定和传输方式。

**4.1 创建客户端类**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    
    namespace WCF.Third.Client
    {
        //回调契约实现
        public class Client:IheartbeatCallback
        {
            private TimeSpan _interval = TimeSpan.FromSeconds(2);    //心跳频率
            public TimeSpan Interval{
                get{return _interval;}
            }
    
            public void UpdateInterval(int seconds)
            {
                lock(this)
                {
                     _interval = TimeSpan.FromSeconds(seconds);
                }
            }
        }
    
        /// <summary>
        /// 回调契约
        /// </summary>
        public interface IheartbeatCallback
        {
            /// <summary>
            /// 回调操作，调整心跳频率
            /// </summary>
            /// <param name="seconds">新的频率</param>
            [OperationContract(IsOneWay = true)]
            void UpdateInterval(int seconds);
        }
    
        /// <summary>
        /// 心跳服务契约
        /// </summary>
        [ServiceContract(CallbackContract = typeof(IheartbeatCallback))]
        public interface IheartbeatService
        {
            [OperationContract]
            void Heartbeat();
        }
    
        //客户端代理的实现
        public class HeartbeatProxy : DuplexClientBase<IheartbeatService>, IheartbeatService
        {
            public HeartbeatProxy(InstanceContext context, Binding binding, EndpointAddress remoteAddress) : base(context, binding, remoteAddress) { }
            public void Heartbeat()
            {
                Channel.Heartbeat();
            }
        }
    }

**4.2 运行客户端类**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.ServiceModel;
    using System.Threading;
    
    namespace WCF.Third.Client
    {
        class Program
        {
            private const string serviceAddressUrl = "net.pipe://localhost/HeartbeatService";   
            static void Main(string[] args)
            {
                try
                {
                    Client client = new Client();
                    using(HeartbeatProxy proxy = new HeartbeatProxy(new InstanceContext(client),new NetNamedPipeBinding(),new EndpointAddress(serviceAddressUrl)))
                    {
                        Console.WriteLine("客户端运行");
                        while (true)
                        {
                            proxy.Heartbeat();                //发送心跳
                            Thread.Sleep(client.Interval);    //等待一个周期时间
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
                finally {
                    Console.Read();
                }
            }
        }
    }