目前.NET Core建立Windows Service比較好的一個開源框架：DasMulli.Win32.ServiceUtils

新建一個.NET Core控制檯程序，搜索並下載Nuget包：DasMulli.Win32.ServiceUtils

GitHub 連接及使用指南

 

Write a windows service using:

using DasMulli.Win32.ServiceUtils;
using System;
using System.Linq;
using System.Threading.Tasks;

class Program
{
    public static void Main(string[] args)
    {
        var myService = new MyService();

        //檢測到--run-as-service命令行參數後，才以windows service方式執行程序
        if (args.Contains("--run-as-service"))
        {
            var serviceHost = new Win32ServiceHost(myService);
            serviceHost.Run();
        }
        //沒檢測到--run-as-service命令行參數，就以控制檯方式執行程序，用於調試
        else
        {
            myService.Start(args, () => { });
            Console.WriteLine("Running interactively, press enter to stop.");
            Console.ReadLine();
            myService.Stop();
        }
    }
}

class MyService : IWin32Service
{
    public string ServiceName => "Test Service";
    protected bool stopFlag = false;
    protected Task serviceTask;

    public void Start(string[] startupArguments, ServiceStoppedCallback serviceStoppedCallback)
    {
        // Start coolness and return

        //注意不要在Start方法中直接用無限循環來執行windows service的處理邏輯，這樣會致使啓動windows service時，啓動永遠沒法執行完畢。
        //正確的作法是像下面同樣，使用Task啓動另一個線程來無限循環執行windows service的處理邏輯，保證Start方法不會被卡死。
        serviceTask = Task.Run(new Action(ServiceHandler));
    }

    /// <summary>
    /// ServiceHandler方法會無限循環來執行windows service的處理邏輯
    /// </summary>
    public void ServiceHandler()
    {
        while (!stopFlag)
        {
            //若是stopFlag爲false，就無限循環，執行windows service的處理邏輯
        }
    }

    public void Stop()
    {
        // shut it down again

        //當中止windows service時，將stopFlag置爲true，便可結束ServiceHandler方法中的無限循環
        stopFlag = true;

        if (serviceTask != null)
        {
            serviceTask.Wait();
        }
    }
}

You can then register your service via sc.exe (run cmd / powershell as administrator!):

sc.exe create MyService DisplayName= "My Service" binpath= "C:\Program Files\dotnet\dotnet.exe C:\path\to\MyService.dll --run-as-service"

注意上面命令中，C:\Program Files\dotnet\dotnet.exe爲你的計算機上dotnet.exe程序所在的路徑地址，C:\path\to\MyService.dll爲你的.NET Core控制檯項目（Windows Service項目）發佈後生成的dll文件地址。

固然，若是你的.NET Core控制檯項目（Windows Service項目）是使用Self-contained deployments (SCD)模式發佈的，生成的是.exe文件，那麼你也能夠直接將生成的.exe文件路徑地址做爲sc.exe的binpath參數，以下所示：

sc.exe create MyService DisplayName= "My Service" binpath= "C:\path\to\MyService.exe --run-as-service"

其中C:\path\to\MyService.exe爲你的.NET Core控制檯項目（Windows Service項目）發佈後生成的.exe文件地址

Then you can change the description of your service with below command:

sc.exe description MyService "This is a testing service"

You can also change the DisplayName of your service with below command:

sc.exe config MyService DisplayName= "My Application Service"

 

You can change windows service username and password with below command:

sc.exe config "[servicename]" obj= "[.\username]" password= "[password]"

Just keep in mind that:

• The spacing in the above example matters. obj= "foo" is correct; obj="foo" is not.
• '.' is an alias to the local machine, you can specify a domain there (or your local computer name) if you wish.
• Passwords aren't validated until the service is started
• Quote your parameters, as above. You can sometimes get by without quotes
• You must stop windows service before you change its username and password

Here is an example to change username and password of MyService

sc.exe config "MyService" obj= "domain\user" password= "password"

關於用sc.exe更改windows service的用戶名和密碼，能夠參考下面兩個提問的帖子:

Using SC.exe to set service credentials password fails

how to set windows service username and password through commandline

 

Now go the services console / task manager and start your service.

Not that sc will install your service as SYSTEM user which has way to many access rights to run things like web apps. See it's reference for more options.
If you want to get rid of it again, use:

sc.exe delete MyService

You can also create a service that registers itself like the example provided by taking a look at the sample source.
Also take a look at the ASP.NET Core MVC sample, which has additional logic to set the correct working directory. When running it in development and not from the published output, be sure to pass --preserve-working-directory to it when registering so that it will run from the project directory (e.g. run dotnet run --register-service --preserve-working-directory from and administrative command prompt).

 

你也能夠建立一個Windows Service本身就包含了註冊服務、卸載服務、運行服務等功能，下面的代碼展現瞭如何對一個叫TestWin32Service的Windows Service進行相關操做：

using System;
using System.Diagnostics;
using System.Linq;
using System.Text.RegularExpressions;
using DasMulli.Win32.ServiceUtils;

namespace TestService
{
    public class Program
    {
        private const string RunAsServiceFlag = "--run-as-service";
        private const string RegisterServiceFlag = "--register-service";
        private const string UnregisterServiceFlag = "--unregister-service";
        private const string InteractiveFlag = "--interactive";

        private const string ServiceName = "DemoService";
        private const string ServiceDisplayName = "Demo .NET Core Service";
        private const string ServiceDescription = "Demo ASP.NET Core Service running on .NET Core";

        public static void Main(string[] args)
        {
            try
            {
                if (args.Contains(RunAsServiceFlag))
                {
                    RunAsService(args);
                }
                else if (args.Contains(RegisterServiceFlag))
                {
                    RegisterService();
                }
                else if (args.Contains(UnregisterServiceFlag))
                {
                    UnregisterService();
                }
                else if (args.Contains(InteractiveFlag))
                {
                    RunInteractive(args);
                }
                else
                {
                    DisplayHelp();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error ocurred: {ex.Message}");
            }
        }

        private static void RunAsService(string[] args)
        {
            var testService = new TestWin32Service(args.Where(a => a != RunAsServiceFlag).ToArray());
            var serviceHost = new Win32ServiceHost(testService);
            serviceHost.Run();
        }

        private static void RunInteractive(string[] args)
        {
            var testService = new TestWin32Service(args.Where(a => a != InteractiveFlag).ToArray());
            testService.Start(new string[0], () => { });
            Console.WriteLine("Running interactively, press enter to stop.");
            Console.ReadLine();
            testService.Stop();
        }

        private static void RegisterService()
        {
            // Environment.GetCommandLineArgs() includes the current DLL from a "dotnet my.dll --register-service" call, which is not passed to Main()
            var remainingArgs = Environment.GetCommandLineArgs()
                .Where(arg => arg != RegisterServiceFlag)
                .Select(EscapeCommandLineArgument)
                .Append(RunAsServiceFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                // For self-contained apps, skip the dll path
                remainingArgs = remainingArgs.Skip(1);
            }

            var fullServiceCommand = host + " " + string.Join(" ", remainingArgs);

            // Do not use LocalSystem in production.. but this is good for demos as LocalSystem will have access to some random git-clone path
            // Note that when the service is already registered and running, it will be reconfigured but not restarted
            var serviceDefinition = new ServiceDefinitionBuilder(ServiceName)
                .WithDisplayName(ServiceDisplayName)
                .WithDescription(ServiceDescription)
                .WithBinaryPath(fullServiceCommand)
                .WithCredentials(Win32ServiceCredentials.LocalSystem)
                //.WithCredentials(new Win32ServiceCredentials("UserName", "Password"))
                .WithAutoStart(true)
                .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, startImmediately: true);

            Console.WriteLine($@"Successfully registered and started service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }

        private static void UnregisterService()
        {
            new Win32ServiceManager()
                .DeleteService(ServiceName);

            Console.WriteLine($@"Successfully unregistered service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }

        private static void DisplayHelp()
        {
            Console.WriteLine(ServiceDescription);
            Console.WriteLine();
            Console.WriteLine("This demo application is intened to be run as windows service. Use one of the following options:");
            Console.WriteLine("  --register-service        Registers and starts this program as a windows service named \"" + ServiceDisplayName + "\"");
            Console.WriteLine("                            All additional arguments will be passed to ASP.NET Core's WebHostBuilder.");
            Console.WriteLine("  --unregister-service      Removes the windows service creatd by --register-service.");
            Console.WriteLine("  --interactive             Runs the underlying asp.net core app. Useful to test arguments.");
        }

        private static string EscapeCommandLineArgument(string arg)
        {
            // http://stackoverflow.com/a/6040946/784387
            arg = Regex.Replace(arg, @"(\\*)" + "\"", @"$1$1\" + "\"");
            arg = "\"" + Regex.Replace(arg, @"(\\+)$", @"$1$1") + "\"";
            return arg;
        }
    }
}