Отладка сервиса через IDE

Question

Я создал программу, которую также можно запускать как службу, и она позволит мне также отлаживать ее, используя следующую команду в файле запуска Program.cs.

using System;
using System.Linq;
using System.Windows.Forms;
using System.ServiceProcess;
using System.Reflection;
using System.Threading;
using crs.Includes;
using crs.Service;
using System.IO;

namespace crs
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            //Convert all arguments to lower
            args = Array.ConvertAll(args, e => e.ToLower());

            //Create the container object for the settings to be stored
            Settings.Bag = new SettingsBag();

            //Check if we want to run this as a service
            bool runAsService = args.Contains("-service");

            //Check if debugging
            bool debug = Environment.UserInteractive;

            //Catch all unhandled exceptions as well
            if (!debug || debug)
            {
                Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
                AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
            }

            if (runAsService)
            {
                //Create service array
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[]
                {
                    new CRSService()
                };

                //Run services in interactive mode if needed
                if (debug)
                    RunInteractive(ServicesToRun);
                else
                    ServiceBase.Run(ServicesToRun);
            }
            else
            {
                //Start the main gui
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new MainGUI());
            }
        }

        #region Functions
        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            Exception ex = e.ExceptionObject as Exception;

            string stackTrace = ex.Message + "/n";
            while (ex.InnerException != null)
            {
                ex = ex.InnerException;

                stackTrace += ex.Message + "/n";
            }
            stackTrace = stackTrace.Substring(0, stackTrace.Length - 2);

            string msg = "UNHANDLED EXCEPTION!/n/n" + stackTrace;

            //Write all log messages to a debug log
            try
            {
                string currentDate = DateTime.Now.ToString("yyyy-MM-dd");
                string debugFilePath = AppDomain.CurrentDomain.BaseDirectory + @"debugLogs\";
                string debugFilename = Application.ProductName + "-debug-" + currentDate + ".log";

                if (!Directory.Exists(debugFilePath))
                {
                    //Create the debug log files directory
                    Directory.CreateDirectory(debugFilePath);
                }
                if (!File.Exists(debugFilePath + debugFilename))
                {
                    //Create the new file
                    using (StreamWriter w = File.CreateText(debugFilePath + debugFilename))
                    {
                        w.WriteLine("Debug log file for " + Application.ProductName + ".");
                        w.WriteLine("Created on " + currentDate + ".");
                        w.WriteLine("");
                    }
                }

                //Write the log message to the file
                using (StreamWriter w = File.AppendText(debugFilePath + debugFilename))
                {
                    w.WriteLine(DateTime.Now.ToString() + " :: " + msg);
                }
            }
            catch
            { }
        }

        private static void RunInteractive(ServiceBase[] servicesToRun)
        {
            Console.WriteLine("Services running in interactive mode.");
            Console.WriteLine();

            MethodInfo onStartMethod = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.Instance | BindingFlags.NonPublic);
            foreach (ServiceBase service in servicesToRun)
            {
                Console.Write("Starting {0}...", service.ServiceName);
                onStartMethod.Invoke(service, new object[] { new string[] { } });
                Console.Write("Started");
            }

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Press any key to stop the services and end the process...");
            Console.ReadKey();
            Console.WriteLine();

            MethodInfo onStopMethod = typeof(ServiceBase).GetMethod("OnStop", BindingFlags.Instance | BindingFlags.NonPublic);
            foreach (ServiceBase service in servicesToRun)
            {
                Console.Write("Stopping {0}...", service.ServiceName);
                onStopMethod.Invoke(service, null);
                Console.WriteLine("Stopped");
            }

            //Keep the console alive for a second to allow the user to see the message.
            Console.WriteLine("All services stopped.");
            Thread.Sleep(1000);
        }
        #endregion
    }
}

Все работает как положено за исключением строки Console.ReadKey(); по методу RunInteractive(). Если бы я попытался запустить этот сервис вручную в окне консоли, у меня не возникло бы никаких проблем, он работает отлично и ждет, когда я нажму Enter, чтобы начать процесс остановки сервиса. Однако, когда он запускается в IDE, он все выплевывает в окно DEBUG, и ему нечего захватить ReadKey.

Как я могу go обойти это при отладке в IDE? Можно ли как-то заставить его запускаться в командном окне при отладке в IDE?

Answer 1

После нескольких копаний я придумал новый класс, чтобы удовлетворить мои потребности. Спасибо за сообщение Павла Я смог получить текст для чтения и записи в новом окне консоли, которое мне нужно было создать, когда его не было.

Моя измененная функция RunInteractive из моего первоначального вопроса:

private static void RunInteractive(ServiceBase[] servicesToRun)
{
    //Account for running this application without a console window (debugging in IDE)
    if (!ConsoleWindow.Exists() && !ConsoleWindow.Create())
        return;

    Console.WriteLine("Services running in interactive mode.");
    Console.WriteLine();

    MethodInfo onStartMethod = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.Instance | BindingFlags.NonPublic);
    foreach (ServiceBase service in servicesToRun)
    {
        Console.Write("Starting {0}...", service.ServiceName);
        onStartMethod.Invoke(service, new object[] { new string[] { } });
        Console.Write("Started");
    }

    Console.WriteLine();
    Console.WriteLine();
    Console.WriteLine("Press any key to stop the services and end the process...");
    Console.ReadKey();
    Console.WriteLine();

    MethodInfo onStopMethod = typeof(ServiceBase).GetMethod("OnStop", BindingFlags.Instance | BindingFlags.NonPublic);
    foreach (ServiceBase service in servicesToRun)
    {
        Console.Write("Stopping {0}...", service.ServiceName);
        onStopMethod.Invoke(service, null);
        Console.WriteLine("Stopped");
    }

    //Keep the console alive for a second to allow the user to see the message.
    Console.WriteLine("All services stopped.");
    Thread.Sleep(1000);
}

Примечание. Единственное, что здесь было добавлено, - это немного вверху функции.

//Account for running this application without a console window (debugging in IDE)
if (!ConsoleWindow.Exists() && !ConsoleWindow.Create())
  return;

Мой новый класс ConsoleWindow:

using System;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace crs.Includes
{
    public class ConsoleWindow
    {
        #region Constants
        private const UInt32 GENERIC_WRITE = 0x40000000;
        private const UInt32 GENERIC_READ = 0x80000000;
        private const UInt32 FILE_SHARE_READ = 0x00000001;
        private const UInt32 FILE_SHARE_WRITE = 0x00000002;
        private const UInt32 OPEN_EXISTING = 0x00000003;
        private const UInt32 FILE_ATTRIBUTE_NORMAL = 0x80;
        #endregion

        #region WinAPI external functions
        [DllImport("kernel32.dll")]
        private static extern IntPtr GetConsoleWindow();

        [DllImport(
            "kernel32.dll",
            SetLastError = true
            )]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool FreeConsole();

        [DllImport(
            "kernel32.dll",
            SetLastError = true
            )]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool AllocConsole();

        [DllImport(
            "kernel32.dll",
            EntryPoint = "CreateFileW",
            SetLastError = true,
            CharSet = CharSet.Auto,
            CallingConvention = CallingConvention.StdCall
            )]
        private static extern IntPtr CreateFileW(
            string lpFileName,
            UInt32 dwDesiredAccess,
            UInt32 dwShareMode,
            IntPtr lpSecurityAttributes,
            UInt32 dwCreationDisposition,
            UInt32 dwFlagsAndAttributes,
            IntPtr hTemplateFil
            );
        #endregion

        #region Public class methods
        public static bool Exists()
        {
            if (GetConsoleWindow() == IntPtr.Zero)
                return false;
            else
                return true;
        }

        public static bool Create()
        {
            try
            {
                if (!AllocConsole())
                    throw new Exception("Error!  Could not get a lock on a console window and could not create one.");

                InitializeOutStream();
                InitializeInStream();

                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            return false;
        }
        #endregion

        #region Functions
        private static void InitializeOutStream()
        {
            FileStream fs = CreateFileStream("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, FileAccess.Write);
            if (fs != null)
            {
                StreamWriter writer = new StreamWriter(fs) { AutoFlush = true };
                Console.SetOut(writer);
                Console.SetError(writer);
            }
        }

        private static void InitializeInStream()
        {
            FileStream fs = CreateFileStream("CONIN$", GENERIC_READ, FILE_SHARE_READ, FileAccess.Read);
            if (fs != null)
                Console.SetIn(new StreamReader(fs));
        }

        private static FileStream CreateFileStream(string name, uint win32DesiredAccess, uint win32ShareMode, FileAccess dotNetFileAccess)
        {
            SafeFileHandle file = new SafeFileHandle(CreateFileW(name, win32DesiredAccess, win32ShareMode, IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero), true);
            if (!file.IsInvalid)
            {
                FileStream fs = new FileStream(file, dotNetFileAccess);
                return fs;
            }
            return null;
        }
        #endregion
    }
}

Answer 2

Вместо console.write вы можете создать файл журнала, в котором вы можете регистрировать статус программы. Я рекомендую использовать пакет log 4net nuget.