WCF 服務的集合管理器的設計

時間 2019-11-06

原文原文鏈接

　　　　今天是2019年2月1日，時間過得針對，立刻就年末了，當前新年也離咱們愈來愈近了。在此，我也祝福常常瀏覽我博客的朋友們「新年快樂、闔家歡樂」，來年有一個好彩頭。在即將結束這一年之計，寫今年的最後一片文章。WCF 我相信你們都使用過，每次宿主該服務的時候都要使用 ServiceHost，若是要加載多個 WCF 服務，那就須要屢次 ServiceHost 實例化，並且這個過程大體都是同樣的，這就有點太麻煩了。正好如今有時間，也有項目的須要，我就寫了一份 WCF 服務的集合管理器，能夠加載多個 WCF 服務，也能夠對 WCF 的服務進行開啓或者關閉的操做，使用起來仍是比較方便的。這個設計已經改過屢次，如今這個版本是目前最合適、最穩定的版本。編程

　　　　說寫就寫，OO的三大基本原則，一、面向抽象編程，不要面向實現編程；二、多組合少繼承；三、哪裏有變化點就封裝哪裏。數組

　　　　這三大原則咱們要死死的記在內心，融化進血液裏，由此，個人作法是作接口的抽象設計，代碼以下：服務器

　　　　一、接口 IWcfServiceManager 的設計以下：函數

 1     /// <summary>
 2     /// WCF 服務的實例管理器，該類型能夠實現對容器內部的 WCF 服務對象進行增長、刪除、查詢、開啓和關閉的操做。
 3     /// </summary>
 4     public interface IWcfServiceManager:IDisposable
 5     {
 6         /// <summary>
 7         /// 以指定的名稱增長 WCF 服務實例，可是該服務並無啓動。
 8         /// </summary>
 9         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
10         /// <returns>返回布爾值，true 表示增長 WCF 服務成功，false 表示增長 WCF 失敗。</returns>
11         bool AddService(string serviceName);
12 
13         /// <summary>
14         /// 從容器對象中刪除指定名稱的 WCF 服務實例。
15         /// </summary>
16         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
17         /// <returns>返回布爾值，true 表示刪除 WCF 服務成功，false 表示刪除 WCF 服務失敗。</returns>
18         bool RemoveService(string serviceName);
19 
20         /// <summary>
21         /// 獲取全部的 WCF 服務實例的集合。
22         /// </summary>
23         /// <returns>返回全部的 WCF 服務實例集合。</returns>
24         IEnumerable<WcfService> GetServices();
25 
26         /// <summary>
27         /// 根據指定的名稱獲取 WCF 服務實例。
28         /// </summary>
29         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
30         /// <returns>返回和指定名稱相匹配的 WCF 服務實例，若是不存在則會返回 Null 值。</returns>
31         WcfService GetService(string serviceName);
32 
33         /// <summary>
34         /// 開啓指定名稱 WCF 服務實例，此時該服務能夠爲客戶端提供服務了。
35         /// </summary>
36         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
37         /// <returns>返回布爾值，true 表示成功開啓 WCF 服務，false 表示開啓式 WCF 服務失敗。</returns>
38         bool Start(string serviceName);
39 
40         /// <summary>
41         /// 開啓全部的 WCF 服務實例。
42         /// </summary>
43         void StartAll();
44 
45         /// <summary>
46         /// 關閉指定名稱的 WCF 服務實例，此時該服務就不能爲客戶端提供任何服務了。
47         /// </summary>
48         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
49         /// <returns>返回布爾值，true 表示成功關閉 WCF 服務實例，false 表示關閉 WCF 服務實例失敗。</returns>
50         bool Close(string serviceName);
51 
52         /// <summary>
53         /// 關閉全部的 WCF 服務實例，中止全部的服務。
54         /// </summary>
55         void CloseAll();        
56 
57         /// <summary>
58         /// 根據指定的名稱來判斷該 WCF 服務實例是否已經開啓。
59         /// </summary>
60         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
61         /// <returns>返回布爾值，true 表示該名稱的 WCF 服務實例是已經開啓的，false 表示該名稱的 WCF 服務實例是未開啓的。</returns>
62         bool IsStartup(string serviceName);
63 
64         /// <summary>
65         /// 獲取 WCF 服務實例的個數
66         /// </summary>
67         int Count { get; }
68     }

　　　　　　　　這個接口的設計就很少說了，很簡單，繼續咱們下一步。單元測試

　　　　二、實現接口類的設計，類名是：WcfServiceManager.cs測試

　　　　　　該類型都有詳細的備註信息，不用我多說了。this

  1     /// <summary>
  2     /// WCF 服務的實例管理器，該類型能夠實現對容器內部的 WCF 服務對象進行增長、刪除、查詢、開啓和關閉的操做。
  3     /// </summary>
  4     public abstract class WcfServiceManager : IWcfServiceManager, IDisposable
  5     {
  6         #region 私有字段
  7 
  8         private ConcurrentDictionary<string, ServiceHost> _serviceHostGroup;
  9         private ConcurrentDictionary<string, ServiceHost> _serviceHostTemp;
 10         private string[] _assemblyNames;
 11         private bool _disposed;//是否回收完畢
 12         private IList<Assembly> _assemblies;
 13 
 14         #endregion
 15 
 16         #region 構造函數
 17 
 18         /// <summary>
 19         /// 初始化 WcfServiceManager 類的實例
 20         /// </summary>        
 21         protected WcfServiceManager()
 22         {            
 23             _serviceHostGroup = new ConcurrentDictionary<string, ServiceHost>();
 24             _serviceHostTemp = new ConcurrentDictionary<string, ServiceHost>();            
 25             _assemblies = new List<Assembly>();
 26         }
 27 
 28         #endregion
 29 
 30         #region 接口方法的實現
 31 
 32         /// <summary>
 33         /// 以指定的名稱增長 WCF 服務實例，可是該服務並無啓動。
 34         /// </summary>
 35         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
 36         /// <returns>返回布爾值，true 表示增長 WCF 服務成功，false 表示增長 WCF 失敗。</returns>
 37         public bool AddService(string serviceName)
 38         {
 39             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
 40             {
 41                 return false;
 42             }
 43             if (!_serviceHostGroup.ContainsKey(serviceName))
 44             {
 45                 Type serviceType = GetServiceTypeFromAssemblies(serviceName,_assemblies);
 46                 if (serviceType != null)
 47                 {
 48                     ServiceHost host = new ServiceHost(serviceType);
 49                     _serviceHostGroup.TryAdd(serviceName, host);
 50                     return true;
 51                 }
 52                 else
 53                 {
 54                     return false;
 55                 }
 56             }
 57             return false;
 58         }
 59 
 60         /// <summary>
 61         /// 從容器對象中刪除指定名稱的 WCF 服務實例。
 62         /// </summary>
 63         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
 64         /// <returns>返回布爾值，true 表示刪除 WCF 服務成功，false 表示刪除 WCF 服務失敗。</returns>
 65         public bool RemoveService(string serviceName)
 66         {
 67             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
 68             {
 69                 return false;
 70             }
 71             if (_serviceHostGroup.ContainsKey(serviceName))
 72             {
 73                 ServiceHost hostInstance = null;
 74                 _serviceHostGroup.TryRemove(serviceName, out hostInstance);
 75                 if (hostInstance != null && hostInstance.State == CommunicationState.Opened)
 76                 {
 77                     hostInstance.Close();
 78                     hostInstance = null;
 79                 }
 80                 return true;
 81             }
 82             return false;
 83         }
 84 
 85         /// <summary>
 86         /// 獲取全部的 WCF 服務實例的集合。
 87         /// </summary>
 88         /// <returns>返回全部的 WCF 服務實例集合。</returns>
 89         public IEnumerable<WcfService> GetServices()
 90         {
 91             IList<WcfService> list = new List<WcfService>();
 92             if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
 93             {
 94                 foreach (var key in _serviceHostGroup.Keys)
 95                 {
 96                     var service = new WcfService();
 97                     service.ServiceName = _serviceHostGroup[key].Description.Name;
 98                     service.State = _serviceHostGroup[key].State;
 99                     service.Description = _serviceHostGroup[key].Description;
100                     list.Add(service);
101                 }
102             }
103             return list;
104         }
105 
106         /// <summary>
107         /// 根據指定的名稱獲取 WCF 服務實例。
108         /// </summary>
109         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
110         /// <returns>返回和指定名稱相匹配的 WCF 服務實例，若是不存在則會返回 Null 值。</returns>
111         public WcfService GetService(string serviceName)
112         {
113             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
114             {
115                 throw new ArgumentNullException("要查找的 WCF 服務的名稱不能爲空！");
116             }
117             WcfService service = null;
118             if (_serviceHostGroup.ContainsKey(serviceName))
119             {
120                 service = new WcfService();
121                 service.ServiceName = _serviceHostGroup[serviceName].Description.Name;
122                 service.State = _serviceHostGroup[serviceName].State;
123                 service.Description = _serviceHostGroup[serviceName].Description;
124                 return service;
125             }
126             return service;
127         }
128 
129         /// <summary>
130         /// 清空容器中全部 WCF 服務實例。
131         /// </summary>
132         public void ClearAll()
133         {
134             if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
135             {
136                 this.CloseAll();
137                 _serviceHostGroup.Clear();
138             }
139         }
140 
141         /// <summary>
142         /// 開啓指定名稱 WCF 服務實例，此時該服務能夠爲客戶端提供服務了。
143         /// </summary>
144         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
145         /// <returns>返回布爾值，true 表示成功開啓 WCF 服務，false 表示開啓式 WCF 服務失敗。</returns>
146         public bool Start(string serviceName)
147         {
148             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
149             {
150                 return false;
151             }
152             var serviceHost = _serviceHostGroup[serviceName];
153             if (serviceHost != null)
154             {
155                 if (serviceHost.State == CommunicationState.Created && serviceHost.State != CommunicationState.Faulted)
156                 {
157                     serviceHost.Open();
158                     return true;
159                 }
160                 else if (serviceHost.State == CommunicationState.Closed || serviceHost.State != CommunicationState.Faulted)
161                 {
162                     ServiceHost tempHost;                    
163                     _serviceHostGroup.TryRemove(serviceName,out tempHost);
164                     if (tempHost != null)
165                     {
166                         if (tempHost.State == CommunicationState.Opened)
167                         {
168                             tempHost.Close();
169                         }
170                         tempHost = null;
171                     }
172                     ServiceHost newhost = new ServiceHost(serviceHost.Description.ServiceType);
173                     newhost.Open();
174                     _serviceHostGroup.TryAdd(serviceName, newhost);
175                     return true;
176                 }
177             }
178             return false;
179         }
180 
181         /// <summary>
182         /// 開啓全部的 WCF 服務實例。
183         /// </summary>
184         public void StartAll()
185         {
186             if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
187             {
188                 foreach (ServiceHost host in _serviceHostGroup.Values)
189                 {
190                     if (host.State != CommunicationState.Opened)
191                     {
192                         if (host.State == CommunicationState.Closed)
193                         {
194                             ServiceHost newhost = new ServiceHost(host.Description.ServiceType);
195                             newhost.Open();
196                             _serviceHostTemp.TryAdd(host.Description.ConfigurationName, newhost);
197                         }
198                         else if (host.State == CommunicationState.Faulted)
199                         {
200                             ServiceHost newhost = new ServiceHost(host.Description.ServiceType);
201                             newhost.Open();
202                             _serviceHostTemp.TryAdd(host.Description.ConfigurationName, newhost);
203                         }
204                         else if (host.State == CommunicationState.Created)
205                         {
206                             host.Open();
207                         }
208                     }
209                 }
210             }
211             if (_serviceHostTemp != null && _serviceHostTemp.Count > 0)
212             {
213                 foreach (KeyValuePair<string, ServiceHost> item in _serviceHostTemp)
214                 {
215                     if (_serviceHostGroup.ContainsKey(item.Key))
216                     {
217                         if (_serviceHostGroup[item.Key].State == CommunicationState.Opened)
218                         {
219                             _serviceHostGroup[item.Key].Close();
220                         }
221                         ServiceHost tempHost;
222                         _serviceHostGroup.TryRemove(item.Key,out tempHost);
223                         if (tempHost.State != CommunicationState.Closed)
224                         {
225                             tempHost.Close();
226                             tempHost = null;
227                         }
228                         if (item.Value.State == CommunicationState.Closed)
229                         {
230                             item.Value.Open();
231                         }
232                         _serviceHostGroup.TryAdd(item.Key, item.Value);
233                     }
234                 }
235                 _serviceHostTemp.Clear();
236             }
237         }
238 
239         /// <summary>
240         /// 關閉指定名稱的 WCF 服務實例，此時該服務就不能爲客戶端提供任何服務了。
241         /// </summary>
242         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
243         /// <returns>返回布爾值，true 表示成功關閉 WCF 服務實例，false 表示關閉 WCF 服務實例失敗。</returns>
244         public bool Close(string serviceName)
245         {
246             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
247             {
248                 return false;
249             }
250             var host = _serviceHostGroup[serviceName];
251             if (host != null)
252             {
253                 if (host.State == CommunicationState.Opened)
254                 {
255                     host.Close();                    
256                 }
257                 return true;
258             }
259             return false;
260         }
261 
262         /// <summary>
263         /// 關閉全部的 WCF 服務實例，中止全部的服務。
264         /// </summary>
265         public void CloseAll()
266         {
267             if (_serviceHostGroup != null && _serviceHostGroup.Count > 0)
268             {
269                 foreach (ServiceHost host in _serviceHostGroup.Values)
270                 {
271                     if (host.State == CommunicationState.Opened)
272                     {
273                         host.Close();
274                     }
275                 }
276             }
277         }        
278 
279         /// <summary>
280         /// 根據指定的名稱來判斷該 WCF 服務實例是否已經開啓。
281         /// </summary>
282         /// <param name="serviceName">表示 WCF 服務的名稱。</param>
283         /// <returns>返回布爾值，true 表示該名稱的 WCF 服務實例是已經開啓的，false 表示該名稱的 WCF 服務實例是未開啓的。</returns>
284         public bool IsStartup(string serviceName)
285         {
286             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
287             {
288                 return false;
289             }
290             var host = _serviceHostGroup[serviceName];
291             if (host != null)
292             {
293                 if (host.State == CommunicationState.Opened)
294                 {
295                     return true;
296                 }
297             }
298             return false;
299         }
300 
301         /// <summary>
302         /// 從新加載全部的 WCF 服務實例，並將全部的 WCF 服務對象開啓
303         /// </summary>
304         public void Reload()
305         {
306             this.CloseAll();
307             this.ClearAll();
308             this.Initialize();
309             this.StartAll();
310         }
311 
312         /// <summary>
313         /// 獲取 WCF 服務實例的個數
314         /// </summary>
315         public int Count
316         {
317             get
318             {
319                 return _serviceHostGroup.Count;
320             }
321         }
322 
323         #endregion
324 
325         #region 定義的抽象方法
326 
327         /// <summary>
328         /// 加載全部的 WCF 服務實例對象
329         /// </summary>
330         /// <param name="assemblyFullNames">承載 WCF 服務的應用程序集的徹底限定名數組</param>
331         public void Initialize(params string[] assemblyFullNames)
332         {
333             _assemblyNames = assemblyFullNames;
334             CloseAll();
335             ClearAll();
336 
337             var currentDomainDlls = GetAssembliesFromCurrentDomain();
338             var specifiedDlls = GetAssembliesFromSpecifiedCondition(_assemblyNames);
339             foreach (var item in currentDomainDlls)
340             {
341                 _assemblies.Add(item);
342             }
343             foreach (var item in specifiedDlls)
344             {
345                 _assemblies.Add(item);
346             }
347 
348             Configuration config = ConfigurationManager.OpenExeConfiguration(Assembly.GetEntryAssembly().Location);
349             ServiceModelSectionGroup serviceModelGroup = config.GetSectionGroup("system.serviceModel") as ServiceModelSectionGroup;
350             if (serviceModelGroup != null)
351             {
352                 foreach (ServiceElement service in serviceModelGroup.Services.Services)
353                 {
354                     this.AddService(service.Name);
355                 }
356             }
357         }
358 
359         /// <summary>
360         /// 根據指定的字符串類型的程序集名稱列表獲取強類型的程序集列表
361         /// </summary>
362         /// <returns>返回獲取到的強類型的程序集列表</returns>
363         protected virtual IList<Assembly> GetAssembliesFromSpecifiedCondition(params string[] assemblyNames)
364         {
365             IList<Assembly> assemblies = new List<Assembly>();
366             if (assemblyNames != null && assemblyNames.Length > 0)
367             {
368                 foreach (var item in assemblyNames)
369                 {
370                     var assembly = Assembly.Load(item);
371                     assemblies.Add(assembly);
372                 }
373             }
374             return assemblies;
375         }
376 
377         /// <summary>
378         /// 根據當前的應用程序域獲取全部必需的程序集
379         /// </summary>
380         /// <returns>返回獲取到當前應用程序域內的程序集列表</returns>
381         protected virtual IList<Assembly> GetAssembliesFromCurrentDomain()
382         {
383             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();
384             return assemblies;
385         }
386 
387         /// <summary>
388         /// 根據 WCF 服務的名稱在當前程序域中或者傳入的程序集中查找該服務的 Type 類型的對象
389         /// </summary>
390         /// <param name="serviceName">要查找的 WCF 服務的名稱</param>
391         /// <param name="assemblies">承載 WCF 服務的程序集列表</param>
392         /// <returns>返回WCF服務的Type類型的對象，若是沒有找到相應的類型就會返回 Null 值。</returns>
393         private Type GetServiceTypeFromAssemblies(string serviceName, IList<Assembly> assemblies)
394         {
395             if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
396             {
397                 throw new ArgumentNullException("要查找的 WCF 服務的名稱");
398             }
399 
400             if (assemblies == null || assemblies.Count == 0)
401             {
402                 throw new ArgumentNullException("待查找的程序集列表不能爲空！");
403             }
404 
405             try
406             {
407                 if (assemblies != null && assemblies.Count() > 0)
408                 {
409                     var currentAssembly = assemblies.FirstOrDefault(a => a.GetType(serviceName) != null);
410                     if (currentAssembly != null)
411                     {
412                         return currentAssembly.GetType(serviceName);
413                     }
414                 }
415             }
416             catch (Exception)
417             {
418                 throw;
419             }
420             return null;
421         }
422 
423         #endregion
424 
425         #region IDispoable模式
426 
427         /// <summary>
428         /// 釋放託管資源
429         /// </summary>
430         public void Dispose()
431         {
432             Dispose(true);
433             GC.SuppressFinalize(this);
434         }
435 
436         /// <summary>
437         /// 析構函數釋放資源
438         /// </summary>
439         ~WcfServiceManager()
440         {
441             Dispose(false);
442         }
443 
444         /// <summary>
445         /// 釋放全部的託管資源和非託管資源核心方法實現
446         /// </summary>
447         /// <param name="disposing">是否須要釋放那些實現IDisposable接口的託管對象</param>
448         protected virtual void Dispose(bool disposing)
449         {
450             if (_disposed)
451             {
452                 return; //若是已經被回收，就中斷執行
453             }
454             if (disposing)
455             {
456                 //TODO:回收託管資源，調用IDisposable的Dispose()方法就能夠
457                 this.CloseAll();
458                 this.ClearAll();
459                 _serviceHostGroup = null;
460             }
461             //TODO:釋放非託管資源，設置對象爲null
462             _disposed = true;
463         }
464 
465         #endregion
466     }

　　　　三、真正實現的葉子結點類型設計，類型是：DefaultWcfServiceManager.cs編碼

　　　　　　　　該類型就是用戶將要使用的類型。spa

 1     /// <summary>
 2     /// WCF 服務的實例管理器，該類型能夠實現對容器內部的 WCF 服務對象進行增長、刪除、查詢、開啓和關閉的操做。
 3     /// </summary>
 4     public sealed class DefaultWcfServiceManager:WcfServiceManager, IDisposable
 5     {
 6         #region 構造函數
 7 
 8         /// <summary>
 9         /// 初始化 DefaultWcfServiceManager 類型的實例
10         /// </summary>
11         public DefaultWcfServiceManager(){ }
12 
13         #endregion
14     }

　　　　　　主要的類型就差很少了。在這個設計過程當中，還會涉及到一個輔助類型 WcfService設計

　　　　四、輔助類型 WcfService 的設計編碼。很簡單，直接上代碼。

 1     /// <summary>
 2     /// WCF 服務實例的類型的定義
 3     /// </summary>
 4     public sealed class WcfService
 5     {
 6         #region 私有字段
 7 
 8         private string _serviceName;
 9         private CommunicationState _communicationState;
10         private ServiceDescription _serviceDescription;
11 
12         #endregion
13 
14         #region 構造函數
15 
16         /// <summary>
17         /// 初始化 WcfService 類型的實例
18         /// </summary>
19         public WcfService()
20         { }
21 
22         #endregion
23 
24         #region 實例屬性
25 
26         /// <summary>
27         /// 獲取或者設置 WCF 服務實例的名稱
28         /// </summary>
29         public string ServiceName
30         {
31             get { return _serviceName; }
32             set
33             {
34                 if ((!string.IsNullOrEmpty(value)) && (!string.IsNullOrWhiteSpace(value)))
35                 {
36                     _serviceName = value;
37                 }
38             }
39         }
40 
41         /// <summary>
42         /// 獲取或者設置 WCF 的服務實例的運行狀態
43         /// </summary>
44         public CommunicationState State
45         {
46             get { return _communicationState; }
47             set { _communicationState = value; }
48         }
49         
50         /// <summary>
51         /// 獲取或者設置 WCF 服務的描述信息
52         /// </summary>
53         public ServiceDescription Description
54         {
55             get { return _serviceDescription; }
56             set
57             {
58                 if (value != null)
59                 {
60                     _serviceDescription = value;
61                 }
62             }
63         }
64 
65         #endregion
66     }

　　　　五、單元測試項目代碼。

　　　　　　　　這是最後的代碼了，有源碼沒有測試代碼，彷佛還少一點。測試代碼以下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //DefaultWcfServiceManager hosts = new DefaultWcfServiceManager("ServiceInstance, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
 6             DefaultWcfServiceManager hosts = new DefaultWcfServiceManager();
 7             hosts.Initialize("ServiceInstance, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
 8             //hosts.Initialize("ServiceInstance");
 9             string operation = "a";
10             do
11             {
12                 operation = Console.ReadLine();
13                 if (string.Compare(operation, "StartAll", true) == 0)
14                 {
15                     hosts.StartAll();
16                     Console.WriteLine("已經所有打開");
17                 }
18 
19                 if (string.Compare(operation, "ConsoleService", true) == 0)
20                 {
21                     hosts.Close("ServiceInstance.ConsoleService");
22                     Console.WriteLine("ConsoleService 已經關閉");
23                 }
24 
25                 if (string.Compare(operation, "ConsoleServiceOpen", true) == 0)
26                 {
27                     hosts.Start("ServiceInstance.ConsoleService");
28                     Console.WriteLine("ConsoleService 已經打開");
29                 }
30 
31                 if (string.Compare(operation, "MathServiceOpen", true) == 0)
32                 {
33                     hosts.Start("ServiceInstance.MathService");
34                     Console.WriteLine("MathService 已經打開");
35                 }
36 
37                 if (string.Compare(operation, "MathService", true) == 0)
38                 {
39                     hosts.Close("ServiceInstance.MathService");
40                     Console.WriteLine("MathService 已經關閉");
41                 }
42 
43                 if (string.Compare(operation, "CloseAll", true) == 0)
44                 {
45                     hosts.CloseAll();
46                     Console.WriteLine("已經所有關閉");
47                 }
48 
49                 if (string.Compare(operation, "Reload", true) == 0)
50                 {
51                     hosts.Reload();
52                     Console.WriteLine("已經所有從新打開");
53                 }
54                 if (string.Compare(operation, "print", true) == 0)
55                 {
56                     foreach (var item in hosts.GetServices())
57                     {
58                         Console.WriteLine("服務地址：" + item.Description.Endpoints[0].Address.Uri.ToString() + "；狀態：" + item.State.ToString());
59                     }
60                 }
61             } while (string.Compare(operation, "exit", true) != 0);
62         }
63     }

　　　　總結：

　　　　　　好了，就寫到這裏吧。要想使用 WCF ，必須的命名空間是必需要引入的 System.ServiceModel，固然這裏省略了必要的配置數據了，我相信，這個不是很難。也要說明一點，我這個項目是放在類庫裏面的，WCF 是分爲 Client 端和 Server 端的，今天只是貼出了服務器端的代碼，若是有須要，在把客戶端生成代理類的代碼貼出來。年尾了，讓很差的東西過去，讓本身迎接新的明天，不忘初心，繼續努力。