C#开发一个混合Windows服务和Windows窗体的程序

很多时候，我们希望服务程序可以直接运行，或者可以响应一些参数，这时候，混合Windows服务和Windows窗体的程序就排上用场了。要实现同时支持Windows服务和Windows窗体，需要在启动的第一步时判断当前运行环境是否为服务模式，可以从以下几个方面进行判断：

• 当前用户名称：Environment.UserName，如果为SYSTEM则可以是服务模式
• 是否用户交互模式：Environment.UserInteractive，为false时也可以认为是服务模式
• 自定义启动参数：创建服务时添加一个特定的启动参数，比如[/s]，然后代码中检查启动参数args[0] == "/s"

如果上述条件都不成立，就进入窗体模式，或者是响应一些其他的命令行参数，比如安装[/i]、卸载服务[/u]等。

项目需要添加下面的组件引用：

• System.Configuration.Install
• System.ServiceModel
• System.ServiceProcess

项目包含的类文件：

• Program.cs：根据运行模式执行服务或者窗体，或者响应命令行参数；
• MainService.cs：服务类，实现与窗体类一致的功能；
• MainForm.cs：窗体类，实现与服务类一致的功能，还可以添加一些安装和卸载服务，启动和停止服务的管理功能；
• MainWorker.cs：实现功能的类，服务类与窗体类都调用该类；
• ServiceInstaller.cs：服务安装类，可以调用框架的InstallUtil.exe工具安装卸载服务。

各个类的代码如下：

• Program.cs 

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.ServiceProcess;
using System.Windows.Forms;

namespace WindowsServiceFormHybridSample
{
    internal static class Program
    {
        public const string SERVICE_NAME = "WindowsServiceFormHybridSample";

        [STAThread]
        static void Main(string[] args)
        {
            //本应用程序为Windows服务和Windows窗体混合的模式
            //如果启动参数为/S，则进入Windows服务模式，否则进入Windows窗体模式
            //如果当前账户名称为SYSTEM，则进入Windows服务模式，否则进入Windows窗体模式

            //var serviceMode = args.Length > 0 && args[0].Equals("/S", StringComparison.OrdinalIgnoreCase);
            var serviceMode = Environment.UserName.Equals("SYSTEM", StringComparison.OrdinalIgnoreCase);
 25             try
            {
                if (serviceMode)
                {
                    //开启Windows服务模式，切勿弹出消息框
                    ServiceBase.Run(new MainService());
                    return;
                }

                //开启Windows窗体模式
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);

                if (args.Length == 0)
                {
                    //打开窗体
                    using (var form = new MainForm())
                    {
                        Application.Run(form);
                    }

                    return;
                }

                //处理命令行参数
                Program.ParseArgs(args);
            }
            catch (Exception ex)
            {
                if (serviceMode)
                {
                    //写入错误日志
                }
                else
                {
                    MessageBox.Show(ex.ToString());
                }
            }
        }

        private static void ParseArgs(string[] args)
        {
            var argInstall = 0;
            var argUninstall = 0;
            var argSilent = 0;
            var argOthers = 0;

            foreach (var arg in args)
            {
                var temp = arg.Replace('/', '-').ToUpper();

                switch (temp)
                {
                    case "-I":
                        argInstall = 1;
                        break;
                    case "-U":
                        argUninstall = 1;
                        break;
                    case "-S":
                        argSilent = 1;
                        break;
                    default:
                        argOthers = 1;
                        break;
                }
            }

            if (argOthers == 1)
            {
                MessageBox.Show(Program.SERVICE_NAME + "支持的命令行参数：\r\n\r\n/i\t安装更新服务\r\n/u{2}卸载更新服务\r\n/s\t静默模式");
            }
            else
            {
                int value = argInstall + argUninstall;

                switch (value)
                {
                    case 0:
                        MessageBox.Show("需要指定[/i]或者[/u]参数。");
                        break;
                    case 2:
                        MessageBox.Show("不能同时指定[/i]和[/u]参数。");
                        break;
                    default:
                        if (argInstall == 1)
                        {
                            Program.InstallServiceA(false, argSilent == 1);
                        }
                        else
                        {
                            Program.InstallServiceB(true, argSilent == 1);
                        }

                        break;
                }
            }
        }

        /// <summary>
        /// 调用.NET Framework框架的InstallUtil.exe工具安装卸载服务，需要项目中包含服务安装类ServiceInstaller.cs
        /// </summary>
        private static void InstallServiceA(bool uninstall = false, bool slient = false)
        {
            try
            {
                var fileName = Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), "InstallUtil.exe");
                var args = string.Format("{0}\"{1}\"", uninstall ? "/U " : string.Empty, Application.ExecutablePath);

                using (var process = Process.Start(new ProcessStartInfo(fileName, args) { WindowStyle = ProcessWindowStyle.Hidden }))
                {
                    process.WaitForExit(10000);
                }

                if (uninstall)
                {
                    return;
                }

                fileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "sc.exe");
                args = string.Format("start \"{0}\"", Program.SERVICE_NAME);

                using (var process = Process.Start(new ProcessStartInfo(fileName, args) { WindowStyle = ProcessWindowStyle.Hidden }))
                {
                    process.WaitForExit(10000);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

        /// <summary>
        /// 调用操作系统的sc.exe工具安装卸载服务
        /// </summary>
        private static void InstallServiceB(bool uninstall = false, bool slient = false)
        {
            try
            {
                var fileName = Path.Combine(Environment.SystemDirectory, "sc.exe");
                var argsList = new List<string>();

                if (!uninstall)
                {
                    argsList.Add(string.Format("create {0} binPath= \"{1}\" start= auto", Program.SERVICE_NAME, Application.ExecutablePath));
                    argsList.Add(string.Format("start {0}", Program.SERVICE_NAME));
                }
                else
                {
                    argsList.Add(string.Format("stop {0}", Program.SERVICE_NAME));
                    argsList.Add(string.Format("delete {0}", Program.SERVICE_NAME));
                }

                foreach (var args in argsList)
                {
                    using (var process = Process.Start(new ProcessStartInfo(fileName, args) { WindowStyle = ProcessWindowStyle.Hidden }))
                    {
                        process.WaitForExit(10000);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }
    }
}

• MainService.cs

using System;
using System.ServiceProcess;

namespace WindowsServiceFormHybridSample
{
    internal class MainService : ServiceBase
    {
        public MainService()
        {
            base.ServiceName = Program.SERVICE_NAME;
        }

        protected override void OnStart(string[] args)
        {
            try
            {
                //这里最好执行异步的方法
                //否则会导致Windows的服务启动超时

                //与MainForm执行相同的方法
                MainWorker.Start();
            }
            catch (Exception ex)
            {
                //写入错误日志
            }
        }

        protected override void OnStop()
        {
            try
            {
                MainWorker.Stop();
            }
            catch (Exception ex)
            {
                //写入错误日志
            }
        }
    }
}

• MainForm.cs

using System;
using System.Windows.Forms;

namespace WindowsServiceFormHybridSample
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            this.InitializeComponent();
            this.button1.Text = "启动服务";
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //与MainService执行相同的方法
            try
            {
                if (this.button1.Text == "启动服务")
                {
                    MainWorker.Start();
                    this.button1.Text = "停止服务";
                    return;
                }

                MainWorker.Stop();
                this.button1.Text = "启动服务";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }
    }
}

• MainWorker.cs

using System;
using System.Threading;
using System.Threading.Tasks;

namespace WindowsServiceFormHybridSample
{
    internal class MainWorker
    {
        private static MainWorker _instance;
        private static CancellationTokenSource _cancellationTokenSource;

        private bool _isBusy;

        public bool IsBusy { get => this._isBusy; }

        static MainWorker()
        {
            MainWorker._instance = new MainWorker();
        }

        private async void DoWork(CancellationToken cancellationToken)
        {
            this._isBusy = true;

            while (!cancellationToken.IsCancellationRequested)
            {
                await Task.Delay(1000);

                //其他耗时任务
            }

            this._isBusy = false;
        }

        public static void Start()
        {
            if (MainWorker._instance.IsBusy)
            {
                throw new Exception("服务正在运行中。");
            }

            MainWorker._cancellationTokenSource = new CancellationTokenSource();
            MainWorker._instance.DoWork(_cancellationTokenSource.Token);
        }

        public static void Stop()
        {
            if (MainWorker._cancellationTokenSource != null)
            {
                MainWorker._cancellationTokenSource.Cancel();
            }
        }
    }
}

• ServiceInstaller.cs

using System.ComponentModel;
using System.Configuration.Install;
using System.ServiceProcess;

namespace WindowsServiceFormHybridSample
{
    [RunInstaller(true)]
    public class ServiceInstaller : Installer
    {
        public ServiceInstaller()
        {
            var ServiceProcessInstaller = new ServiceProcessInstaller()
            {
                Account = ServiceAccount.LocalSystem
            };

            var ServiceInstaller = new System.ServiceProcess.ServiceInstaller
            {
                ServiceName = Program.SERVICE_NAME,
                StartType = ServiceStartMode.Automatic
            };

            base.Installers.AddRange(new Installer[] { ServiceProcessInstaller, ServiceInstaller });
        }
    }
}