用WCF实现对无人终端的远程监控

-

最进在项目中，遇到了一个需要在远程监视自动运行软件的实时情况的例子。因为MS面向服务方面有WCF，而且看了一些资料，觉得WCF比较适合这个应用。因此决定用WCF来实现这个功能。

首先，先说一下具体的应用，监控，顾名思义，有两个方面的意思，一方面是”监”，也就是远程要能实时查看终端的各种情况。这里其实指的就是被监控的要能主动的，实时的向远程控制端发送自己的情况。另一方面是控，即远程端能够发布命令控制终端进行执行。并由终端返回一定的执行信息。

而且这里是一种一对一对多的关系，即一个终端可以被多个管理端监控。实际上一个管理端也可以监控多个终端，在是这种分析中，我们可以明白，真正运行服务的是终端，而不是管理端。

简单起见，假定远程发送命令的操作是void Operation(),终端更新的操作是UpdateStatus();

这个想法，从设计到实现，经历以下三种阶段的变形。

最初的想法，是一个Service类。一个接口。即

即控制端调用operation发送命令，终端调用UpdateStatus更新状态。

对应的，要有一定的回调，即控制端发送Operation时，终端要有一个callBack进行接收，相应的，当终端用UpdateStatus时，控制端也要有一个callBack进行接收。

当这两种操作被集成到一个服务中时，我们的wcf接口变成了如下结构。

 

 

namespace Geyunfei.WCF
{
    [ServiceContract(

    SessionMode = SessionMode.Required
   ,
  CallbackContract = typeof(ISeviceCallBack)
         )]
    public interface IService
    {
        [OperationContract]
        /// <summary>
        /// 远程发送控制命令
        /// </summary>
        /// 
        void Operation();

        [OperationContract]
        /// <summary>
        /// 更新状态
        /// </summary>
        void UpdateStatus();
    }
    
    public interface ISeviceCallBack
    {

      
        void ReceiveStatus();
        
        void ReceiveCommand();
    }
    public static class Global
    {
        public static List<ISeviceCallBack> callBacks = new List<ISeviceCallBack>();
    }
    [ServiceBehavior]
    public class Service : IService,IDisposable 
    {
        ISeviceCallBack callBack;
        #region IService Members
        public Service()
        {
            callBack = System.ServiceModel.OperationContext.Current.GetCallbackChannel<ISeviceCallBack>();

            Global.callBacks.Add(callBack);
           
        }

        /// <summary>
        /// 当服务端调用这个时，向终端发命令
        /// </summary>
        public void Operation()
        {

            foreach (var r in Global.callBacks)
            {
                r.ReceiveCommand();
            }
        }
        /// <summary>
        /// 当终端调用时，向服务端发命令
        /// </summary>
        public void UpdateStatus()
        {
            foreach (var r in Global.callBacks)
            {
                r.ReceiveStatus();
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            Global.callBacks.Remove(this.callBack);
        }

        #endregion
    }
}

 

这样做实现起来比较方便，但是缺点也是很明显的，因为实际上终端只需要调用updateStatus，并回调receiveCommand,而管理端只需要调用Operation,回调receiveUpdateStatus(),现在这两种操作同时暴露给了终端和管理端 ，因此从设计上，这是一种不安全设计。。而且在调用相应的操作时，服务端自己又回得到相应的callBack，让人感到很费解。

那么下一步的想法，显然是把面向终端和管理端的服务进行分开。同时，用全局的变量或MSMQ进行交互，这里为了简单起见，只使用了List<>，没有使用委托。

这时，我们的设计变成了如下的形式：

 

namespace Geyunfei.WCF2
{
    /// <summary>
    /// 面向终端的服务
    /// </summary>
    [ServiceContract(

    SessionMode = SessionMode.Required
   ,
  CallbackContract = typeof(ITerminalSeviceCallBack )
         )]
    public interface ITerminalService
    {
        [OperationContract]
        /// <summary>
        /// 更新状态
        /// </summary>
        void UpdateStatus();
    }

    /// <summary>
    /// 面向管理端的服务
    /// </summary>
    [ServiceContract(

    SessionMode = SessionMode.Required
   ,
  CallbackContract = typeof(IControlSeviceCallBack)
         )]
    public interface IControlService
    {
        [OperationContract]
        /// <summary>
        /// 远程发送控制命令
        /// </summary>
        /// 
        void Operation();
    }

    public interface ITerminalSeviceCallBack
    {
        void ReceiveCommand();
    }

    public interface IControlSeviceCallBack
    {
        void ReceiveStatus();
    }
    public static class Global
    {
        public static List<IControlSeviceCallBack > controlcallBacks = new List<IControlSeviceCallBack >();
        public static List<ITerminalSeviceCallBack> terminalcallBacks = new List<ITerminalSeviceCallBack>();
    }
    [ServiceBehavior]
    public class TerminalService : ITerminalService, IDisposable
    {
         ITerminalSeviceCallBack callBack;
        #region IService Members
         public TerminalService()
        {
            callBack = System.ServiceModel.OperationContext.Current.GetCallbackChannel<ITerminalSeviceCallBack>();
            Global.terminalcallBacks .Add(callBack);

        }
        /// <summary>
        /// 当终端调用时，向服务端发命令
        /// </summary>
        public void UpdateStatus()
        {
            foreach (var r in Global.controlcallBacks)
            {
                r.ReceiveStatus();
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            Global.terminalcallBacks .Remove(this.callBack);
        }

        #endregion
    }


    [ServiceBehavior]
    public class ControlService : IControlService, IDisposable
    {
        IControlSeviceCallBack  callBack;
        #region IService Members
        public ControlService()
        {
            callBack = System.ServiceModel.OperationContext.Current.GetCallbackChannel<IControlSeviceCallBack >();

            Global.controlcallBacks .Add(callBack);

        }

        /// <summary>
        /// 当服务端调用这个时，向终端发命令
        /// </summary>
        public void Operation()
        {

            foreach (var r in Global.terminalcallBacks)
            {
                r.ReceiveCommand();
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            Global.controlcallBacks .Remove(this.callBack);
        }

        #endregion
    }
}

现在，终端和管理端的服务分开了，接口也清晰了。

但是这样做又有另一个缺点，即我的每一个终端是只运行一个软件的，即我在运行terminalService时，只有一个点在接入。这时，我为这一个点开一个服务，是一种浪费 。

于是，就有了第三种方案。即服务是面向管理端的。终端只实例一个简单的承载体，如下:

这时，我们的方案就已经接近完美了。

 

 

namespace Geyunfei.WCF3
{
    [ServiceContract(

    SessionMode = SessionMode.Required
   ,
  CallbackContract = typeof(ISeviceCallBack)
         )]
    public interface IService
    {
        [OperationContract]
        /// <summary>
        /// 远程发送控制命令
        /// </summary>
        void Operation();
    }

    public interface ISeviceCallBack
    {
        void ReceiveStatus();
    }
    public static class Global
    {
        public static List<ISeviceCallBack> callBacks = new List<ISeviceCallBack>();
        public static ReceiveCommandHandler receiveCommad;
    }
    [ServiceBehavior]
    public class Service : IService, IDisposable
    {
        ISeviceCallBack callBack;
        #region IService Members
        public Service()
        {
            callBack = System.ServiceModel.OperationContext.Current.GetCallbackChannel<ISeviceCallBack>();
            Global.callBacks.Add(callBack);

        }
        /// <summary>
        /// 当终端调用时，向服务端发命令
        /// </summary>
        public void Operation()
        {

            if (Global.receiveCommad != null)
                Global.receiveCommad();
        }
        #endregion
        #region IDisposable Members
        public void Dispose()
        {
            Global.callBacks.Remove(this.callBack);
        }

        #endregion
    }


   
    public delegate void ReceiveCommandHandler();
    public class ServiceHost
    {
        public ServiceHost()
        {
        }

        public void Start()
        {
            //在这里启动运行一个Service服务
        }
        public void Stop()
        {
            //在这里停止服务
        }


        /// <summary>
        /// 当收到远程的命令时，触发此事件
        /// </summary>
        public event ReceiveCommandHandler ReceveCommand
        {
            add
            {
                Global.receiveCommad += value;
            }
            remove
            {
                Global.receiveCommad -= value;
            }
        }


        /// <summary>
        /// 更新状态
        /// </summary>
        public void UpdateStatus()
        {
            foreach (var r in Global.callBacks)
            {
                r.ReceiveStatus();
            }
        }

    }
}

 

以上是我在开发中的一些体会，从第一种到第三种，可能老鸟们看着很弱智，只接就能使用第三种设计，但是对于一个初学者，直接想到这种方案可能比较困难，欢迎大家讨论。