How to Run a Windows Service as a Console App

Typically, Windows Services are designed to run in the background, which means they don’t have a UI and don't show output directly to developers.

When you try to run a Windows Service project directly in Visual Studio, you might encounter an error message: "Cannot start service from the command line or a debugger. A Windows Service must first be installed...". This error can be frustrating, but there is an easy solution: run the service as a console app conditionally.

In this article, we will explore how to run your Windows Service as a console application for debugging purposes, so you can streamline your development process.

Create a console application project or modify the output type of your project by right-clicking on your project in the Solution Explorer and selecting Properties.

Go to the Application tab and change the Output Type to Console Application.

The next step is to write logic in your Main method that will conditionally determine whether the service should run as a Windows Service or as a console application. You can check for a command-line argument (such as /CONSOLE) to decide which mode to run in.

If you don’t change the output type, running the service will result in an exception: System.InvalidOperationException: "Cannot read keys when either application does not have a console or when console input has been redirected from a file. Try Console.Read."

If the /CONSOLE argument is provided, the program will run as a console app. Otherwise, it will run as a service.

using System;
using System.Linq;
using System.ServiceProcess;

namespace MySimpleWindowsService
{
    static class Program
    {
        public static void Main(string[] args)
        {
            if (args.FirstOrDefault()?.ToUpper() == "/CONSOLE")
                RunAsConsole();
            else
                RunAsService();
        }

        private static void RunAsConsole()
        {
            TestService srv = new TestService();
            srv.StartService();
            Console.WriteLine("Running service as console. Press any key to stop.");
            Console.ReadKey();
            srv.Stop();
        }

        private static void RunAsService()
        {
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[] { new MyService() };
            ServiceBase.Run(ServicesToRun);
        }
    }
}

In a Windows Service, the OnStart method is where the service begins execution. However, if you want to run the service as a console app as well, you need to centralize the service's main logic in a separate method, like StartService(), that can be called from both the service and the console app.

It’s essential to avoid doing heavy initialization in OnStart() because Windows enforces a startup time for services, and if your initialization takes too long, the service won’t start correctly.

using System;
using System.ServiceProcess;
using System.Threading;

namespace MySimpleWindowsService
{
    public partial class MyService : ServiceBase
    {
        private Timer _timer;

        public MyService()
        {
            InitializeComponent();
        }

        // This method is called when the service starts
        protected override void OnStart(string[] args)
        {
            // Example: Start a timer that runs every 10 seconds
            _timer = new Timer(TimerCallback, null, 0, 10000); // 10 seconds interval
        }

        // This method is called when the service stops
        protected override void OnStop()
        {
            // Stop the timer when the service stops
            _timer?.Dispose();
        }

        // Timer callback method to perform actions every 10 seconds
        private void TimerCallback(object state)
        {
            // This is just an example - print a message to the event log
            EventLog.WriteEntry("MyService is running. The current time is: " + DateTime.Now);
        }
    }
}

To make testing easier during development, you can set up Visual Studio to automatically run the program as a console app whenever you run it in Debug mode.

1. Right-click your project in Solution Explorer and select Properties.
2. Go to the Debug tab.
3. In the Command line arguments box, add /CONSOLE.

This setting ensures that whenever you run the project in Debug mode, it will automatically execute as a console application. Remember to leave this empty for the Release configuration to ensure it doesn’t run as a console app in production.

If you need to run your Windows Service as a console app in production for any reason, you can still do so manually. Open a command prompt and run your executable with the /CONSOLE argument like this:

YourService.exe /CONSOLE

To run the service, it needs to be installed on your machine. This can be done using the sc command or by creating an installer for your service.

You need to build the project to generate the executable (MySimpleWindowsService.exe).

Next, Open a Command Prompt with administrator privileges.

Run the following command to install the service:

sc create MySimpleWindowsService binPath= "C:\service\MySimpleWindowsService.exe"

After the service is installed, you can start it with:

sc start MySimpleWindowsService

To stop the service, run:

sc stop MySimpleWindowsService

You can also uninstall the service using:

sc delete MySimpleWindowsService

Since the service writes output to the Windows Event Log, you can view the logs through Event Viewer:

• Open the Event Viewer (eventvwr.msc).
• Navigate to Windows Logs > Application.
• Look for entries under Source for your service (MySimpleWindowsService).

This method allows you to switch between running the service as a background process or as a console application, making it easier to debug and test without having to install the service each time.