WCF 服务的集合管理器的设计

　　　　今天是2019年2月1日，时间过得针对，马上就年底了，当前新年也离我们越来越近了。在此，我也祝福经常浏览我博客的朋友们“新年快乐、阖家欢乐”，来年有一个好彩头。在即将结束这一年之计，写今年的最后一片文章。WCF 我相信大家都使用过，每次宿主该服务的时候都要使用 ServiceHost，如果要加载多个 WCF 服务，那就需要多次 ServiceHost 实例化，而且这个过程大致都是一样的，这就有点太麻烦了。正好现在有时间，也有项目的需要，我就写了一份 WCF 服务的集合管理器，可以加载多个 WCF 服务，也可以对 WCF 的服务进行开启或者关闭的操作，使用起来还是比较方便的。这个设计已经改过多次，现在这个版本是目前最合适、最稳定的版本。

　　　　说写就写，OO的三大基本原则，1、面向抽象编程，不要面向实现编程；2、多组合少继承；3、哪里有变化点就封装哪里。

　　　　这三大原则我们要死死的记在心里，融化进血液里，由此，我的做法是做接口的抽象设计，代码如下：

　　　　

　　　　1、接口 IWcfServiceManager 的设计如下：

    /// <summary>
    /// WCF 服务的实例管理器，该类型可以实现对容器内部的 WCF 服务对象进行增加、删除、查询、开启和关闭的操作。
    /// </summary>
    public interface IWcfServiceManager:IDisposable
    {
        /// <summary>
        /// 以指定的名称增加 WCF 服务实例，但是该服务并没有启动。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示增加 WCF 服务成功，false 表示增加 WCF 失败。</returns>
        bool AddService(string serviceName);

        /// <summary>
        /// 从容器对象中删除指定名称的 WCF 服务实例。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示删除 WCF 服务成功，false 表示删除 WCF 服务失败。</returns>
        bool RemoveService(string serviceName);

        /// <summary>
        /// 获取所有的 WCF 服务实例的集合。
        /// </summary>
        /// <returns>返回所有的 WCF 服务实例集合。</returns>
        IEnumerable<WcfService> GetServices();

        /// <summary>
        /// 根据指定的名称获取 WCF 服务实例。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回和指定名称相匹配的 WCF 服务实例，如果不存在则会返回 Null 值。</returns>
        WcfService GetService(string serviceName);

        /// <summary>
        /// 开启指定名称 WCF 服务实例，此时该服务可以为客户端提供服务了。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示成功开启 WCF 服务，false 表示开启式 WCF 服务失败。</returns>
        bool Start(string serviceName);

        /// <summary>
        /// 开启所有的 WCF 服务实例。
        /// </summary>
        void StartAll();

        /// <summary>
        /// 关闭指定名称的 WCF 服务实例，此时该服务就不能为客户端提供任何服务了。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示成功关闭 WCF 服务实例，false 表示关闭 WCF 服务实例失败。</returns>
        bool Close(string serviceName);

        /// <summary>
        /// 关闭所有的 WCF 服务实例，停止所有的服务。
        /// </summary>
        void CloseAll();        

        /// <summary>
        /// 根据指定的名称来判断该 WCF 服务实例是否已经开启。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示该名称的 WCF 服务实例是已经开启的，false 表示该名称的 WCF 服务实例是未开启的。</returns>
        bool IsStartup(string serviceName);

        /// <summary>
        /// 获取 WCF 服务实例的个数
        /// </summary>
        int Count { get; }
    }

　　　　　　　　这个接口的设计就不多说了，很简单，继续我们下一步。

　　　　2、实现接口类的设计，类名是：WcfServiceManager.cs

　　　　　　该类型都有详细的备注信息，不用我多说了。

    /// <summary>
    /// WCF 服务的实例管理器，该类型可以实现对容器内部的 WCF 服务对象进行增加、删除、查询、开启和关闭的操作。
    /// </summary>
    public abstract class WcfServiceManager : IWcfServiceManager, IDisposable
    {
        #region 私有字段

        private ConcurrentDictionary<string, ServiceHost> _serviceHostGroup;
        private ConcurrentDictionary<string, ServiceHost> _serviceHostTemp;
        private string[] _assemblyNames;
        private bool _disposed;//是否回收完毕
        private IList<Assembly> _assemblies;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化 WcfServiceManager 类的实例
        /// </summary>        
        protected WcfServiceManager()
        {            
            _serviceHostGroup = new ConcurrentDictionary<string, ServiceHost>();
            _serviceHostTemp = new ConcurrentDictionary<string, ServiceHost>();            
            _assemblies = new List<Assembly>();
        }

        #endregion

        #region 接口方法的实现

        /// <summary>
        /// 以指定的名称增加 WCF 服务实例，但是该服务并没有启动。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示增加 WCF 服务成功，false 表示增加 WCF 失败。</returns>
        public bool AddService(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                return false;
            }
            if (!_serviceHostGroup.ContainsKey(serviceName))
            {
                Type serviceType = GetServiceTypeFromAssemblies(serviceName,_assemblies);
                if (serviceType != null)
                {
                    ServiceHost host = new ServiceHost(serviceType);
                    _serviceHostGroup.TryAdd(serviceName, host);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return false;
        }

        /// <summary>
        /// 从容器对象中删除指定名称的 WCF 服务实例。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示删除 WCF 服务成功，false 表示删除 WCF 服务失败。</returns>
        public bool RemoveService(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                return false;
            }
            if (_serviceHostGroup.ContainsKey(serviceName))
            {
                ServiceHost hostInstance = null;
                _serviceHostGroup.TryRemove(serviceName, out hostInstance);
                if (hostInstance != null && hostInstance.State == CommunicationState.Opened)
                {
                    hostInstance.Close();
                    hostInstance = null;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// 获取所有的 WCF 服务实例的集合。
        /// </summary>
        /// <returns>返回所有的 WCF 服务实例集合。</returns>
        public IEnumerable<WcfService> GetServices()
        {
            IList<WcfService> list = new List<WcfService>();
            if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
            {
                foreach (var key in _serviceHostGroup.Keys)
                {
                    var service = new WcfService();
                    service.ServiceName = _serviceHostGroup[key].Description.Name;
                    service.State = _serviceHostGroup[key].State;
                    service.Description = _serviceHostGroup[key].Description;
                    list.Add(service);
                }
            }
            return list;
        }

        /// <summary>
        /// 根据指定的名称获取 WCF 服务实例。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回和指定名称相匹配的 WCF 服务实例，如果不存在则会返回 Null 值。</returns>
        public WcfService GetService(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                throw new ArgumentNullException("要查找的 WCF 服务的名称不能为空！");
            }
            WcfService service = null;
            if (_serviceHostGroup.ContainsKey(serviceName))
            {
                service = new WcfService();
                service.ServiceName = _serviceHostGroup[serviceName].Description.Name;
                service.State = _serviceHostGroup[serviceName].State;
                service.Description = _serviceHostGroup[serviceName].Description;
                return service;
            }
            return service;
        }

        /// <summary>
        /// 清空容器中所有 WCF 服务实例。
        /// </summary>
        public void ClearAll()
        {
            if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
            {
                this.CloseAll();
                _serviceHostGroup.Clear();
            }
        }

        /// <summary>
        /// 开启指定名称 WCF 服务实例，此时该服务可以为客户端提供服务了。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示成功开启 WCF 服务，false 表示开启式 WCF 服务失败。</returns>
        public bool Start(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                return false;
            }
            var serviceHost = _serviceHostGroup[serviceName];
            if (serviceHost != null)
            {
                if (serviceHost.State == CommunicationState.Created && serviceHost.State != CommunicationState.Faulted)
                {
                    serviceHost.Open();
                    return true;
                }
                else if (serviceHost.State == CommunicationState.Closed || serviceHost.State != CommunicationState.Faulted)
                {
                    ServiceHost tempHost;                    
                    _serviceHostGroup.TryRemove(serviceName,out tempHost);
                    if (tempHost != null)
                    {
                        if (tempHost.State == CommunicationState.Opened)
                        {
                            tempHost.Close();
                        }
                        tempHost = null;
                    }
                    ServiceHost newhost = new ServiceHost(serviceHost.Description.ServiceType);
                    newhost.Open();
                    _serviceHostGroup.TryAdd(serviceName, newhost);
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 开启所有的 WCF 服务实例。
        /// </summary>
        public void StartAll()
        {
            if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
            {
                foreach (ServiceHost host in _serviceHostGroup.Values)
                {
                    if (host.State != CommunicationState.Opened)
                    {
                        if (host.State == CommunicationState.Closed)
                        {
                            ServiceHost newhost = new ServiceHost(host.Description.ServiceType);
                            newhost.Open();
                            _serviceHostTemp.TryAdd(host.Description.ConfigurationName, newhost);
                        }
                        else if (host.State == CommunicationState.Faulted)
                        {
                            ServiceHost newhost = new ServiceHost(host.Description.ServiceType);
                            newhost.Open();
                            _serviceHostTemp.TryAdd(host.Description.ConfigurationName, newhost);
                        }
                        else if (host.State == CommunicationState.Created)
                        {
                            host.Open();
                        }
                    }
                }
            }
            if (_serviceHostTemp != null && _serviceHostTemp.Count > 0)
            {
                foreach (KeyValuePair<string, ServiceHost> item in _serviceHostTemp)
                {
                    if (_serviceHostGroup.ContainsKey(item.Key))
                    {
                        if (_serviceHostGroup[item.Key].State == CommunicationState.Opened)
                        {
                            _serviceHostGroup[item.Key].Close();
                        }
                        ServiceHost tempHost;
                        _serviceHostGroup.TryRemove(item.Key,out tempHost);
                        if (tempHost.State != CommunicationState.Closed)
                        {
                            tempHost.Close();
                            tempHost = null;
                        }
                        if (item.Value.State == CommunicationState.Closed)
                        {
                            item.Value.Open();
                        }
                        _serviceHostGroup.TryAdd(item.Key, item.Value);
                    }
                }
                _serviceHostTemp.Clear();
            }
        }

        /// <summary>
        /// 关闭指定名称的 WCF 服务实例，此时该服务就不能为客户端提供任何服务了。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示成功关闭 WCF 服务实例，false 表示关闭 WCF 服务实例失败。</returns>
        public bool Close(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                return false;
            }
            var host = _serviceHostGroup[serviceName];
            if (host != null)
            {
                if (host.State == CommunicationState.Opened)
                {
                    host.Close();                    
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// 关闭所有的 WCF 服务实例，停止所有的服务。
        /// </summary>
        public void CloseAll()
        {
            if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
            {
                foreach (ServiceHost host in _serviceHostGroup.Values)
                {
                    if (host.State == CommunicationState.Opened)
                    {
                        host.Close();
                    }
                }
            }
        }        

        /// <summary>
        /// 根据指定的名称来判断该 WCF 服务实例是否已经开启。
        /// </summary>
        /// <param name="serviceName">表示 WCF 服务的名称。</param>
        /// <returns>返回布尔值，true 表示该名称的 WCF 服务实例是已经开启的，false 表示该名称的 WCF 服务实例是未开启的。</returns>
        public bool IsStartup(string serviceName)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                return false;
            }
            var host = _serviceHostGroup[serviceName];
            if (host != null)
            {
                if (host.State == CommunicationState.Opened)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 重新加载所有的 WCF 服务实例，并将所有的 WCF 服务对象开启
        /// </summary>
        public void Reload()
        {
            this.CloseAll();
            this.ClearAll();
            this.Initialize();
            this.StartAll();
        }

        /// <summary>
        /// 获取 WCF 服务实例的个数
        /// </summary>
        public int Count
        {
            get
            {
                return _serviceHostGroup.Count;
            }
        }

        #endregion

        #region 定义的抽象方法

        /// <summary>
        /// 加载所有的 WCF 服务实例对象
        /// </summary>
        /// <param name="assemblyFullNames">承载 WCF 服务的应用程序集的完全限定名数组</param>
        public void Initialize(params string[] assemblyFullNames)
        {
            _assemblyNames = assemblyFullNames;
            CloseAll();
            ClearAll();

            var currentDomainDlls = GetAssembliesFromCurrentDomain();
            var specifiedDlls = GetAssembliesFromSpecifiedCondition(_assemblyNames);
            foreach (var item in currentDomainDlls)
            {
                _assemblies.Add(item);
            }
            foreach (var item in specifiedDlls)
            {
                _assemblies.Add(item);
            }

            Configuration config = ConfigurationManager.OpenExeConfiguration(Assembly.GetEntryAssembly().Location);
            ServiceModelSectionGroup serviceModelGroup = config.GetSectionGroup("system.serviceModel") as ServiceModelSectionGroup;
            if (serviceModelGroup != null)
            {
                foreach (ServiceElement service in serviceModelGroup.Services.Services)
                {
                    this.AddService(service.Name);
                }
            }
        }

        /// <summary>
        /// 根据指定的字符串类型的程序集名称列表获取强类型的程序集列表
        /// </summary>
        /// <returns>返回获取到的强类型的程序集列表</returns>
        protected virtual IList<Assembly> GetAssembliesFromSpecifiedCondition(params string[] assemblyNames)
        {
            IList<Assembly> assemblies = new List<Assembly>();
            if (assemblyNames != null && assemblyNames.Length > 0)
            {
                foreach (var item in assemblyNames)
                {
                    var assembly = Assembly.Load(item);
                    assemblies.Add(assembly);
                }
            }
            return assemblies;
        }

        /// <summary>
        /// 根据当前的应用程序域获取所有必需的程序集
        /// </summary>
        /// <returns>返回获取到当前应用程序域内的程序集列表</returns>
        protected virtual IList<Assembly> GetAssembliesFromCurrentDomain()
        {
            IList<Assembly> assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => (!a.FullName.StartsWith("System", StringComparison.OrdinalIgnoreCase) && (!a.FullName.StartsWith("Microsoft", StringComparison.OrdinalIgnoreCase)) && (!a.FullName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase)) && (!a.FullName.StartsWith("vshost32", StringComparison.OrdinalIgnoreCase)) && (!a.FullName.StartsWith("SMDiagnostics", StringComparison.OrdinalIgnoreCase)))).ToList();
            return assemblies;
        }

        /// <summary>
        /// 根据 WCF 服务的名称在当前程序域中或者传入的程序集中查找该服务的 Type 类型的对象
        /// </summary>
        /// <param name="serviceName">要查找的 WCF 服务的名称</param>
        /// <param name="assemblies">承载 WCF 服务的程序集列表</param>
        /// <returns>返回WCF服务的Type类型的对象，如果没有找到相应的类型就会返回 Null 值。</returns>
        private Type GetServiceTypeFromAssemblies(string serviceName, IList<Assembly> assemblies)
        {
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                throw new ArgumentNullException("要查找的 WCF 服务的名称");
            }

            if (assemblies == null || assemblies.Count == 0)
            {
                throw new ArgumentNullException("待查找的程序集列表不能为空！");
            }

            try
            {
                if (assemblies != null && assemblies.Count() > 0)
                {
                    var currentAssembly = assemblies.FirstOrDefault(a => a.GetType(serviceName) != null);
                    if (currentAssembly != null)
                    {
                        return currentAssembly.GetType(serviceName);
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
            return null;
        }

        #endregion

        #region IDispoable模式

        /// <summary>
        /// 释放托管资源
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 析构函数释放资源
        /// </summary>
        ~WcfServiceManager()
        {
            Dispose(false);
        }

        /// <summary>
        /// 释放所有的托管资源和非托管资源核心方法实现
        /// </summary>
        /// <param name="disposing">是否需要释放那些实现IDisposable接口的托管对象</param>
        protected virtual void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return; //如果已经被回收，就中断执行
            }
            if (disposing)
            {
                //TODO:回收托管资源，调用IDisposable的Dispose()方法就可以
                this.CloseAll();
                this.ClearAll();
                _serviceHostGroup = null;
            }
            //TODO:释放非托管资源，设置对象为null
            _disposed = true;
        }

        #endregion
    }

　　　　3、真正实现的叶子结点类型设计，类型是：DefaultWcfServiceManager.cs

　　　　　　　　该类型就是用户将要使用的类型。

　　　　　　　　

    /// <summary>
    /// WCF 服务的实例管理器，该类型可以实现对容器内部的 WCF 服务对象进行增加、删除、查询、开启和关闭的操作。
    /// </summary>
    public sealed class DefaultWcfServiceManager:WcfServiceManager, IDisposable
    {
        #region 构造函数

        /// <summary>
        /// 初始化 DefaultWcfServiceManager 类型的实例
        /// </summary>
        public DefaultWcfServiceManager(){ }

        #endregion
    }

　　　　　　主要的类型就差不多了。在这个设计过程中，还会涉及到一个辅助类型 WcfService

　　　　4、辅助类型 WcfService 的设计编码。很简单，直接上代码。

　　　　　　

    /// <summary>
    /// WCF 服务实例的类型的定义
    /// </summary>
    public sealed class WcfService
    {
        #region 私有字段

        private string _serviceName;
        private CommunicationState _communicationState;
        private ServiceDescription _serviceDescription;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化 WcfService 类型的实例
        /// </summary>
        public WcfService()
        { }

        #endregion

        #region 实例属性

        /// <summary>
        /// 获取或者设置 WCF 服务实例的名称
        /// </summary>
        public string ServiceName
        {
            get { return _serviceName; }
            set
            {
                if ((!string.IsNullOrEmpty(value)) && (!string.IsNullOrWhiteSpace(value)))
                {
                    _serviceName = value;
                }
            }
        }

        /// <summary>
        /// 获取或者设置 WCF 的服务实例的运行状态
        /// </summary>
        public CommunicationState State
        {
            get { return _communicationState; }
            set { _communicationState = value; }
        }
        
        /// <summary>
        /// 获取或者设置 WCF 服务的描述信息
        /// </summary>
        public ServiceDescription Description
        {
            get { return _serviceDescription; }
            set
            {
                if (value != null)
                {
                    _serviceDescription = value;
                }
            }
        }

        #endregion
    }

　　　　5、单元测试项目代码。

　　　　　　　　这是最后的代码了，有源码没有测试代码，似乎还少一点。测试代码如下：

　　　　　　　　

    class Program
    {
        static void Main(string[] args)
        {
            //DefaultWcfServiceManager hosts = new DefaultWcfServiceManager("ServiceInstance, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
            DefaultWcfServiceManager hosts = new DefaultWcfServiceManager();
            hosts.Initialize("ServiceInstance, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
            //hosts.Initialize("ServiceInstance");
            string operation = "a";
            do
            {
                operation = Console.ReadLine();
                if (string.Compare(operation, "StartAll", true) == 0)
                {
                    hosts.StartAll();
                    Console.WriteLine("已经全部打开");
                }

                if (string.Compare(operation, "ConsoleService", true) == 0)
                {
                    hosts.Close("ServiceInstance.ConsoleService");
                    Console.WriteLine("ConsoleService 已经关闭");
                }

                if (string.Compare(operation, "ConsoleServiceOpen", true) == 0)
                {
                    hosts.Start("ServiceInstance.ConsoleService");
                    Console.WriteLine("ConsoleService 已经打开");
                }

                if (string.Compare(operation, "MathServiceOpen", true) == 0)
                {
                    hosts.Start("ServiceInstance.MathService");
                    Console.WriteLine("MathService 已经打开");
                }

                if (string.Compare(operation, "MathService", true) == 0)
                {
                    hosts.Close("ServiceInstance.MathService");
                    Console.WriteLine("MathService 已经关闭");
                }

                if (string.Compare(operation, "CloseAll", true) == 0)
                {
                    hosts.CloseAll();
                    Console.WriteLine("已经全部关闭");
                }

                if (string.Compare(operation, "Reload", true) == 0)
                {
                    hosts.Reload();
                    Console.WriteLine("已经全部重新打开");
                }
                if (string.Compare(operation, "print", true) == 0)
                {
                    foreach (var item in hosts.GetServices())
                    {
                        Console.WriteLine("服务地址：" + item.Description.Endpoints[0].Address.Uri.ToString() + "；状态：" + item.State.ToString());
                    }
                }
            } while (string.Compare(operation, "exit", true) != 0);
        }
    }

　　　　总结：

　　　　　　好了，就写到这里吧。要想使用 WCF ，必须的命名空间是必须要引入的 System.ServiceModel，当然这里省略了必要的配置数据了，我相信，这个不是很难。也要说明一点，我这个项目是放在类库里面的，WCF 是分为 Client 端和 Server 端的，今天只是贴出了服务器端的代码，如果有需要，在把客户端生成代理类的代码贴出来。年尾了，让不好的东西过去，让自己迎接新的明天，不忘初心，继续努力。