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 > )
             {
                 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 > )
             {
                 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 > )
             {
                 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 > )
             {
                 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 > )
             {
                 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 > )
             {
                 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 == )
             {
                 throw new ArgumentNullException("待查找的程序集列表不能为空！");
             }

             try
             {
                 if (assemblies != null && assemblies.Count() > )
                 {
                     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) == )
                 {
                     hosts.StartAll();
                     Console.WriteLine("已经全部打开");
                 }

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

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

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

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

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

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

　　　　总结：

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