Adding a Console via Program logic

Question

I have a windows service. If I start it from the debugger I want to run with console output (since you can not run a service).

Usually a Windows Service is set to WindowApplication as project type and has no "window" entry point. Thus it removes the good old console.

If you want a console window you need to change the project type to ConsoleAppication. I would like to do this within the program itself instead changing the Project settings.

Is it possible?

you can also try [this approach](http://stackoverflow.com/questions/8984683/how-to-disable-designer-in-derived-classes-in-following-generations) — Tamir, Jan 25 '12 at 17:01

score 2 · Answer 1 · answered Jan 25 '12 at 16:41

2

You can use the AllocConsole API

[DllImport("kernel32.dll")]
static extern bool AllocConsole();

Use FreeConsole to detach the console from your process:

[DllImport("kernel32.dll")]
static extern bool FreeConsole();

answered Jan 25 '12 at 16:41

Thomas Levesque

286,951
70
623
758

ExCodeCowboy · Accepted Answer · 2012-01-25T17:09:59.123

Actually you can use a simple check when the program starts to see if it is running as a service or not and then use the AllocConsole command to start the console. Here is the sample code.

namespace TestService 
{
   static class Program
   {
        [DllImport("kernel32.dll")]
        static extern bool AllocConsole();

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main()
        {
            if (!Environment.UserInteractive)                                
            {
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[] 
                { 
                    new Service1() 
                };
                ServiceBase.Run(ServicesToRun);
            }
            else 
            {
                AllocConsole();
                //Start Code that interfaces with console.
            }           
         }        
     }
 }

No need for `GetStdHandle`. The [`Environment.UserInteractive`](http://msdn.microsoft.com/en-us/library/system.environment.userinteractive(v=vs.100).aspx) property tells you whether the application is running as a service or an interactive program. — David Brown, Jan 25 '12 at 17:04
I favor Debugger.IsAttached over Environment.UserInteractive for different reasons, but the solution is just fine. Thanks. — Jaster, Jan 26 '12 at 09:54

Andrea Colleoni · Answer 3 · 2012-01-25T17:18:31.893

I usually develop any program as a class library (or set of libraries), with a logical entry point, then I add the launcher project wrapper: a console application, a windows service, a web site.

If, in your program, you have an entry point (a class with a method that starts all your business logic), then you can build it as a class library without any changes and add a console project and a windows service project to your solution that, in the main class (e.g. Program.cs) instantiates the entry point and call the entry method.

This approach does not invade your business logic with use approach and lets you build every mode of use every time you build the entire solution. In other words it allows you to separates concerns: the program and how to launch it.

same as some other answers. would require additional testing and even different deployments. so its not an opption. — Jaster, Jan 26 '12 at 09:51

score 0 · Answer 4 · answered Jan 25 '12 at 16:42

A good practise is having two programs (i.e. two projects in Visual Studio producing executables, plus one or more projects for the shared application logic):

One for a Windows Service variant of your software;
Another one for a console variant of your software.

The advantage is you can choose freely whether to run the software as a service or in console mode. For example, when run in console mode, with frameworks like Log4Net you can configure logging output to the console which helps in diagnosing problems in production environments.

Martijn B · Answer 5 · 2012-01-26T09:56:46.827

Yes you can do it on multiple ways. I use the following solution:

Create a Console Application project. Name it Console.Service or something else.

Go to your service class and create the following code:

private static void Main()
{            
    #if !DEBUG
    var servicesToRun = new [] { new DemoService() };

    Debug.WriteLine("Run service...");
    Run(servicesToRun);      
    #else
    DemoService service = new DemoService();

    service.OnStart(null);

    Console.WriteLine("Press ENTER to quit...");
    Console.ReadLine();

    service.OnStop();

    #endif
}

Add a existing item to the Console Application project by linking to the Service class from your service project. You do this by clicking on the arrow next to the add button (Add as Link).

You're done. Like I said there are multiple ways to go. Choose the one you feel most happy with.

Adding a Console via Program logic

5 Answers5

Linked