一、引言

在软件开发过程中windows服务有的时候非常有用，用于同步数据，发送邮件，宿主WF引擎服务等，但是快速搭建一个好用多线程进行多任务处理的程序往往是一个项目必须考虑的问题。自己在项目中也经常碰到类似的问题，但是一直没有做过这方面总结，每次需要相关windows服务，也重头写一次。自己几乎没有写博客的习惯，前不久看到博客园中有篇关于windows服务的框架写的非常好（抱歉，当时看完以后忘记收藏），感觉自己这些年对它也有一定的认识，但是很少拿出来和大家分享。其实大家都知道通过分享才能找到问题并能提高代码的质量。经过国庆期间的初步整理一个windows服务快速实现的解决方案终于调试通过，当然里面也有一定的问题，希望大伙能指出，谢谢。

二、通用Windows服务接口

定义ICommand作为windows service服务接口,所有自定义的服务都应实现ICommand

aaarticlea/png;base64,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" alt="" />

三、定义WindowsServiceItem对象与WindowsServiceItemCollection集合

服务的每个任务对应一个WindowsServiceItem，一个服务对应多个任务这样定义WindowsServiceItemCollection集合进行维护每个任务。其实WindowsServiceItem中实现了WindowsTimer周期属性，Type为自定义服务的类型.这里只是简单的对象定义大伙应该一看就明白。

aaarticlea/png;base64,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" alt="" />

以下是WindowsTimer的定义.

  1. public class WindowsTimer : IDisposable
  2.     {
  3.         /// <summary>
  4.         /// 周期任务描述
  5.         /// </summary>
  6.         public string Description = string.Empty;
  7.  
  8.         /// <summary>
  9.         /// 时钟周期控件
  10.         /// </summary>
  11.         public Timer Timer = new Timer();
  12.  
  13.         /// <summary>
  14.         /// 是否准备好了可以接受下一个周期的任务
  15.         /// </summary>
  16.         public bool Prepared = true;
  17.  
  18.         /// <summary>
  19.         /// Windows服务的时间控件异常回调委托
  20.         /// </summary>
  21.         public WindowsServiceTimerExceptionCallBack CallBack;
  22.  
  23.         /// <summary>
  24.         /// 构造函数
  25.         /// </summary>
  26.         /// <param name="description">周期任务描述</param>
  27.         /// <param name="interval">执行周期间隔毫秒数</param>
  28.         public WindowsTimer(string description, double interval)
  29.         {
  30.             Description = description;
  31.             Timer.Interval = interval;
  32.             Timer.Enabled = false;
  33.         }
  34.  
  35.         #region IDisposable Members
  36.  
  37.         /// <summary>
  38.         /// 析构函数
  39.         /// </summary>
  40.         ~WindowsTimer()
  41.         {
  42.             Dispose(false);
  43.         }
  44.  
  45.         /// <summary>
  46.         ///
  47.         /// </summary>
  48.         public void Dispose()
  49.         {
  50.             Dispose(true);
  51.             GC.SuppressFinalize(this);
  52.         }
  53.  
  54.         /// <summary>
  55.         ///
  56.         /// </summary>
  57.         /// <param name="disposing"></param>
  58.         protected virtual void Dispose(bool disposing)
  59.         {
  60.             if (disposing)
  61.             {
  62.                 if (Timer != null)
  63.                 {
  64.                     Timer.Dispose();
  65.                 }
  66.             }
  67.         }
  68.  
  69.         #endregion
  70.     }

四、快速搭建Windows服务核心Windows服务类

该类继承 System.ServiceProcess.ServiceBase重写相关的基类方法。在此之前定义两个默认Command：WindowsServiceDefaultCommand和WindowsServiceEmptyCommand

aaarticlea/png;base64,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" alt="" />

核心WindowsService代码如下：

  1. [Serializable]
  2.     public class WindowsService : System.ServiceProcess.ServiceBase
  3.     {
  4.         private bool _fHasInitServerRemotingObject;
  5.         private readonly object _fHasInitServerRemotingObjectLock = new object();
  6.  
  7.         private readonly WindowsServiceItemCollection _fTimerServices = new WindowsServiceItemCollection();
  8.  
  9.         private readonly object _fTimerServiceObjectsLock = new object();
  10.         private readonly Dictionary<Type, ICommand> _fTimerServiceObjects = new Dictionary<Type, ICommand>();
  11.  
  12.         /// <summary>
  13.         /// 构造函数
  14.         /// </summary>
  15.         /// <param name="timerServices"></param>
  16.         public WindowsService(WindowsServiceItemCollection timerServices)
  17.         {
  18.             if (timerServices != null)
  19.             {
  20.                 foreach (WindowsServiceItem item in timerServices)
  21.                 {
  22.                     _fTimerServices.Add(item);
  23.                 }
  24.             }
  25.         }
  26.  
  27.         /// <summary>
  28.         /// 服务启动执行的操作
  29.         /// </summary>
  30.         /// <param name="args"></param>
  31.         protected override void OnStart(string[] args)
  32.         {
  33.             if (_fTimerServices.Count == )
  34.             {
  35.                 var wsiEmpty = new WindowsServiceItem
  36.                     {
  37.                         WindowsTimer = new WindowsTimer("默认的一个Command的轮询周期，设置为5分钟。", ),
  38.                         CommandType = typeof (WindowsServiceEmptyCommand)
  39.                     };
  40.                 _fTimerServices.Add(wsiEmpty);
  41.             }
  42.  
  43.             var wsi = new WindowsServiceItem
  44.                 {
  45.                     WindowsTimer = new WindowsTimer("默认的一个Command的轮询周期，设置为5秒钟。", ),
  46.                     CommandType = typeof (WindowsServiceDefaultCommand)
  47.                 };
  48.             _fTimerServices.Add(wsi);
  49.  
  50.             foreach (WindowsServiceItem kvp in _fTimerServices)
  51.             {
  52.                 kvp.WindowsTimer.Timer.Elapsed -= Timer_Elapsed;
  53.                 kvp.WindowsTimer.Timer.Elapsed += Timer_Elapsed;
  54.                 kvp.WindowsTimer.Timer.Enabled = true;
  55.             }
  56.  
  57.         }
  58.  
  59.         private void Timer_Elapsed(object sender, ElapsedEventArgs e)
  60.         {
  61.             try
  62.             {
  63.                 #region 获取Command对象
  64.  
  65.                 WindowsServiceItem wsItem = _fTimerServices.GetItemByTimer((Timer)sender);
  66.                 Type commandType = wsItem.CommandType;
  67.                 ICommand command = null;
  68.                 if (!_fTimerServiceObjects.ContainsKey(commandType))
  69.                 {
  70.                     lock (_fTimerServiceObjectsLock)
  71.                     {
  72.                         if (!_fTimerServiceObjects.ContainsKey(commandType))
  73.                         {
  74.                             var cmd = Activator.CreateInstance(commandType) as ICommand;
  75.                             _fTimerServiceObjects.Add(commandType, cmd);
  76.                             command = cmd;
  77.                         }
  78.                     }
  79.                 }
  80.                 else
  81.                 {
  82.                     command = _fTimerServiceObjects[commandType];
  83.                 }
  84.  
  85.                 #endregion
  86.  
  87.                 if (!wsItem.WindowsTimer.Prepared)
  88.                 {
  89.                     return;
  90.                 }
  91.  
  92.                 if (command != null)
  93.                 {
  94.                     lock (wsItem.WindowsTimer)
  95.                     {
  96.                         try
  97.                         {
  98.                             wsItem.WindowsTimer.Prepared = !wsItem.WindowsTimer.Prepared;
  99.                             command.Execute();
  100.                         }
  101.                         catch (Exception ex)
  102.                         {
  103.                             //这里不应该导致整个服务终止，而只是把这个错误信号传递到外面去。
  104.                             if (wsItem.WindowsTimer.CallBack != null)
  105.                             {
  106.                                 var args = new WindowsServiceTimerExceptionArgs(ex, e);
  107.                                 try
  108.                                 {
  109.                                     wsItem.WindowsTimer.CallBack(wsItem.WindowsTimer, args);
  110.                                 }
  111.                                 catch (Exception ex1)
  112.                                 {
  113.                                     LogHelper.WriteErrorLog(ex1.ToString());
  114.                                 }
  115.                             }
  116.                         }
  117.                         finally
  118.                         {
  119.                             wsItem.WindowsTimer.Prepared = !wsItem.WindowsTimer.Prepared;
  120.                         }
  121.                     }
  122.                 }
  123.             }
  124.             catch (Exception ex)
  125.             {
  126.                 LogHelper.WriteErrorLog(ex.ToString());
  127.             }
  128.         }
  129.  
  130.         /// <summary>
  131.         /// 服务停止执行的操作
  132.         /// </summary>
  133.         protected override void OnStop()
  134.         {
  135.             try
  136.             {
  137.                 foreach (WindowsServiceItem kvp in _fTimerServices)
  138.                 {
  139.                     kvp.WindowsTimer.Timer.Enabled = false;
  140.                     try
  141.                     {
  142.                         kvp.WindowsTimer.Timer.Dispose();
  143.                     }
  144.                     catch (Exception ex)
  145.                     {
  146.                         LogHelper.WriteErrorLog(ex.ToString());
  147.                     }
  148.                 }
  149.             }
  150.             catch (Exception ex)
  151.             {
  152.                 LogHelper.WriteErrorLog(ex.ToString());
  153.             }
  154.         }
  155.  
  156.         /// <summary>
  157.         /// 释放Timer资源
  158.         /// </summary>
  159.         /// <param name="disposing"></param>
  160.         protected override void Dispose(bool disposing)
  161.         {
  162.             if (disposing)
  163.             {
  164.                 if (_fTimerServices != null)
  165.                 {
  166.                     var timers = new List<WindowsTimer>();
  167.                     foreach (WindowsServiceItem wt in _fTimerServices)
  168.                     {
  169.                         timers.Add(wt.WindowsTimer);
  170.                     }
  171.  
  172.                     _fTimerServices.Clear();
  173.                     foreach (WindowsTimer wt in timers)
  174.                     {
  175.                         wt.Dispose();
  176.                     }
  177.                 }
  178.             }
  179.             base.Dispose(disposing);
  180.         }
  181.     }

五、服务demo

开始服务demo的时候，这里我们这里稍微介绍服务帮助类WindowsServiceHelper.cs主要用于执行服务和异常的管理

  1. /// <summary>
  2.     /// Windows服务辅助类
  3.     /// </summary>
  4.     [Serializable]
  5.     public class WindowsServiceHelper
  6.     {
  7.         /// <summary>
  8.         ///
  9.         /// </summary>
  10.         static WindowsServiceHelper()
  11.         {
  12.  
  13.         }
  14.  
  15.         /// <summary>
  16.         /// 执行Windows服务
  17.         /// </summary>
  18.         public static void RunServices(WindowsServiceItemCollection timerServices, WindowsServiceTimerExceptionCallBack callBack)
  19.         {
  20.             WindowsServiceItemCollection.IsWindowsServiceEnviroments = true;
  21.  
  22.             try
  23.             {
  24.                 if (timerServices == null)
  25.                 {
  26.                     throw new ArgumentNullException("timerServices");
  27.                 }
  28.  
  29.                 if (callBack != null)
  30.                 {
  31.                     foreach (WindowsServiceItem kvp in timerServices)
  32.                     {
  33.                         kvp.WindowsTimer.CallBack += callBack;
  34.                     }
  35.                 }
  36.  
  37.                 var servicesToRun = new ServiceBase[]
  38.                 {
  39.                     new WindowsService(timerServices)
  40.                 };
  41.  
  42.                 foreach (ServiceBase service in servicesToRun)
  43.                 {
  44.                     service.AutoLog = true;
  45.                 }
  46.  
  47.                 AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
  48.  
  49.                 ServiceBase.Run(servicesToRun);
  50.             }
  51.             catch (Exception ex)
  52.             {
  53.                 LogHelper.WriteErrorLog(ex.ToString());
  54.                 throw;
  55.             }
  56.         }
  57.  
  58.         /// <summary>
  59.         /// 未处理异常的处理
  60.         /// </summary>
  61.         /// <param name="sender"></param>
  62.         /// <param name="e"></param>
  63.         private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
  64.         {
  65.             try
  66.             {
  67.                 if (e != null)
  68.                 {
  69.                     if (e.ExceptionObject != null)
  70.                     {
  71.                         if (e.ExceptionObject is Exception)
  72.                         {
  73.                             LogHelper.WriteErrorLog(e.ExceptionObject.ToString());
  74.                         }
  75.                     }
  76.                 }
  77.             }
  78.             catch (Exception ex)
  79.             {
  80.                 LogHelper.WriteErrorLog(ex.ToString());
  81.             }
  82.         }
  83.     }

接下来我们创建一个简单的Demo

重新创建一个控制台程序，创建一个SendSmsCommand.cs 用于发信息，再创建一个SysDataToDataBase.cs用于同步数据到数据库。

  1.  public class SendSmsCommand:ICommand
  2.     {
  3.         public void Execute()
  4.         {
  5.             // 服务的业务逻辑核心代码
  6.             DoSomething();
  7.         }
  8.     }
  1.  public class SysDataToDataBase:ICommand
  2.     {
  3.         public void Execute()
  4.         {
  5.             // 服务的业务逻辑核心代码
  6.             DoSomething();
  7.         }
  8.     }

接下来就是将业务相关的服务进行注册，打开Program.cs修改main函数的代码如下：

  1.  static void Main(string[] args)
  2.          {
  3.              try
  4.              {
  5.                  AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
  6.                  var timerServices = new WindowsServiceItemCollection();
  7.  
  8.                  RegisterSendSmsService(timerServices);
  9.                  RegisterSynDateService(timerServices);
  10.                  WindowsServiceHelper.RunServices(timerServices, WindowsServiceTimerExceptionCallBack);
  11.  
  12.              }
  13.              catch(Exception ex)
  14.              {
  15.                  WriterLog(ex.ToString(), "error");
  16.              }
  17.  
  18.          }

RegisterSendSmsService方法就是用来注册发送信息服务，RegisterSynDateService用来注册同步数据服务。相关实现如下：

  1.  private static void RegisterSynDateService(WindowsServiceItemCollection timerServices)
  2.         {
  3.             try
  4.             {
  5.                 const double interval = ;
  6.                 var sendTimer = new WindowsTimer("SendSynDataInterval", interval);
  7.                 timerServices.Add(sendTimer, typeof(SysDataToDataBase));
  8.             }
  9.             catch (Exception ex)
  10.             {
  11.                 Console.Write(ex);
  12.                 WriterLog(ex.ToString(), "error");
  13.             }
  14.         }
  15.  
  16.         static void RegisterSendSmsService(WindowsServiceItemCollection timerServices)
  17.         {
  18.             #region 发送短信服务
  19.             try
  20.             {
  21.                 const double interval = ;
  22.                 var sendTimer = new WindowsTimer("SendSMSInterval", interval);
  23.                 timerServices.Add(sendTimer, typeof(SendSmsCommand));
  24.             }
  25.             catch (Exception ex)
  26.             {
  27.                 Console.Write(ex);
  28.                 WriterLog(ex.ToString(), "error");
  29.             }
  30.             #endregion
  31.         }

六、写在最后

本快速搭建windows服务解决方案，主要好处就接口开发容易搭建多任务服务。服务框架也业务逻辑分离。把核心代码抽取到底层类库或者底层框架中，为团队其他成员创建服务带来便捷，他们不需要关心服务的如何具体实现的，只专注业务逻辑开发。

本人很少写博客，也很少写总结相关文档，这次算是第一次写博客，语言和条理上自己感觉也比较混乱，自认为自己还是在学习阶段，需要想园区很多同仁学习，如果存在问题或者不理解地方欢迎大家文明讨论。再次谢谢大家。

快速搭建多线程Windows服务解决方案的更多相关文章

  1. Tensorflow平台快速搭建：Windows 7+TensorFlow 0.12.0

    Tensorflow平台快速搭建:Windows 7+TensorFlow 0.12.0 1.TensorFlow 0.12.0下载 2016年11月29日,距离TensorFlow 宣布开源刚刚过去 ...

  2. 快速搭建 SpringCloud 微服务开发环境的脚手架

    本文适合有 SpringBoot 和 SpringCloud 基础知识的人群,跟着本文可使用和快速搭建 SpringCloud 项目. 本文作者:HelloGitHub-秦人 HelloGitHub ...

  3. Spring-boot:快速搭建微框架服务

    前言: Spring Boot是为了简化Spring应用的创建.运行.调试.部署等而出现的,使用它可以做到专注于Spring应用的开发,而无需过多关注XML的配置. 简单来说,它提供了一堆依赖打包,并 ...

  4. 通过express快速搭建一个node服务

    Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台.可以理解为是运行在服务端的 JavaScript.如果你是一个前端程序员,不太擅长像PHP.Python或Ruby等 ...

  5. 快速搭建建SSH服务

    一般来说如果用Ubuntu作为服务器,我们经常需要通过其他客户端远程连接它. 远程连接需要使用SSH,这里列出了一个快速完成这一任务的方法. 键入命令 # sudo apt-get install o ...

  6. 使用FileZilla快速搭建FTP文件服务

    为了便于平时对文件的存储访问,特意搭建FTP服务 FTP服务器(File Transfer Protocol Server)是在互联网上提供文件存储和访问服务的计算机,它们依照FTP协议提供服务. F ...

  7. 快速搭建本地Nuget服务

    一  创建Nuget 服务项目 1.创建一个空白的asp.net web项目,需要.net 4.6以上 2.在Nuget中搜索 nuget.server ,可以看到是由 .Net 基金再维护的,几乎傻 ...

  8. GIS应用|快速搭建REST地图服务

    SuperMap Online云存储作为您的"在线GIS云盘",除了可以在云端存储GIS数据,还可以将数据直接发布多种REST服务,为您节省购买和部署SuperMap iServe ...

  9. 玩转Windows服务系列——使用Boost.Application快速构建Windows服务

    玩转Windows服务系列——创建Windows服务一文中,介绍了如何快速使用VS构建一个Windows服务.Debug.Release版本的注册和卸载,及其原理和服务运行.停止流程浅析分别介绍了Wi ...

随机推荐

  1. iOS app审核参考信息地址

    发件人:(苹果开发支持邮箱地址) 中国区电话:400-670-1855 chinadev<chinadev@asia.apple.com>   您好: 感谢您与 Apple 开发者计划支持 ...

  2. 混合使用C++语言和Objective-C语言

    如果你的源文件扩展名是.m的,你还需要改成.mm,这样编译器才知道你将会在该文件中混合使用C++语言和Objective-C语言.

  3. BZOJ 1090 - 区间dp

    Magic Door 题目大意: 给一个字符串,可以将重复的串缩成x(a),表示x个a,求能缩成的最小长度. 题目分析 区间dp: dp[i][j]表示i~j处理后的最小长度, 则有 \[dp[i][ ...

  4. 二叉苹果树 - 二叉树树型DP

    传送门 中文题面: 题目描述 有一棵苹果树,如果树枝有分叉,一定是分 2 叉(就是说没有只有 1 个儿子的结点,这棵树共有N 个结点(叶子点或者树枝分叉点),编号为1-N,树根编号一定是1. 我们用一 ...

  5. 谈谈android缓存文件

    ##内部存储 总是可用的 这里的文件默认是只能被你的app所访问的. 当用户卸载你的app的时候,系统会把internal里面的相关文件都清除干净. Internal是在你想确保不被用户与其他app所 ...

  6. Ultra-wideband (UWB) secure wireless device pairing and associated systems

    Methods and systems are disclosed for ultra-wideband (UWB) secure wireless device pairing. Secure pa ...

  7. WPF 通过位处理合并图片

    原文:WPF 通过位处理合并图片 本文告诉大家,在使用 WPF 合并两张图片的处理,可以使用像素之间的与或和异或的方式,对三个颜色的通道进行处理. 先给大家看一下软件的界面 这就是通过将左边的两张图片 ...

  8. Matlab使用鼠标标注图像位置并返回坐标（标注图像ROI）

    代码 function ROI=LabelBox(filename) Mat=imread(filename); imshow(Mat); mouse=imrect; pos=getPosition( ...

  9. c语言学习笔记（4）——流程控制

    一.什么是流程控制 程序代码执行的顺序 流程控制分类 顺序执行 选择执行 定义 有选择的执行某些代码 分类 if switch 循环执行 定义 某些代码会被重复执行 分类 for while do w ...

  10. 在.net core不同的版本中 webabi引用的包不同

    core2.0中: 为了要使用MVC Controller 要安装 Microsoft.AspNetCore.Mvc.Core包 Core2.1中:Microsoft.AspNetCore.App