Debugging a Service

Hi Folks,

I'm writing my first windows service, and am having some difficulty debugging. Based on this article...

http://msdn.microsoft.com/en-us/libr...b3(VS.80).aspx

...I understand I can't debug directly from the IDE, but even after installing the service and attaching to the process my breakpoints don't hit. I know the service is running and going through my functions because I'm writing a log and can see things happening there. It would be nice, though to take advantage of the IDE's debugging features. I'm using Visual Studio 2008 Standard, .NET 3.5.

Thanks!

If you get clever with partial classes and some compiler directives you can make it so that in debug mode you can run as a process not a service, it makes it much easier to debug, you just have to remember to follow the rules of a service (no ui's etc)...

Here is an example

Code:

---

#if DEBUG
    public partial class MyService
    {
        [DllImport("Kernel32.dll")]
        static extern void AllocConsole();
        static MyService()
        {
            AllocConsole();
        }

        public void Start(string[] args)
        {
            try
            {
                SafeStart();
                Console.WriteLine("Press any key to exit");
                Console.ReadKey();
                Stop();
            }
            catch (Exception ex)
            {
                //Do something with exception...
            }
        }

        public void Stop()
        {
            try
            {
                SafeStop();
            }
            catch (Exception ex)
            {
                //Do something with exception...
            }
        }
    }
#else
    public partial class MyService
        : ServiceBase
    {
        protected override void OnStart(string[] args)
        {
            base.OnStart(args);
            try
            {
                SafeStart();
            }
            catch (Exception ex)
            {
                //Do something with exception...
            }

        }

        protected override void OnStop()
        {
            base.OnStop();
            try
            {
                SafeStop();
            }
            catch (Exception ex)
            {
                //Do something with exception...
            }
        }
    }
#endif

    public partial class MyService
    {
        private void SafeStop()
        {
            throw new NotImplementedException();
        }

        private void SafeStart()
        {
            throw new NotImplementedException();
        }
    }

    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
#if DEBUG
            (new MyService()).Start(args) ;
#else
            ServiceBase.Run(new ServiceBase[] { new  MyService() });
#endif
        }
    }

---

To help debugging, I find that you just moving the implementation out of the ServiceBase derived class is a simple approach.

Code:

---

public partial class MyService : ServiceBase
{
  // MyServiceImpl implements actual service functionality
  private MyServiceImpl _myServiceImpl = new MyServiceImpl( );

  public MyService ( )
  {
    InitializeComponent();
  }

  // Delegate all calls to MyServiceImpl

  protected override void OnStart(string[] args)
  {
    _myServiceImpl.OnStart( args );
  }

  protected override void OnStop( )
  {
    _myServiceImpl.OnStop( );
  }

  //
  // Other services methods delegated
  //
}
}

---

Then the implementation class can be instantiated directly in debug mode:

Code:

---

private static void Main(string[] args)
{
  // If 'debug' or '/debug' command line switch specified, start in debug mode.
  if (Utility.IsDebugMode(args))
  {
    // Run as a Console-hosted process
    var myServiceImpl = new MyServiceImpl( );
    myServiceImpl.OnStart( args );
  }
  else
  {
    // Run as a Windows Service
    ServiceBase.Run(new ServiceBase[] {new MyService()});
  }
}

---

Note: the IsDebugMode method just checks the command line for the /debug switch.

This approach works well for debugging. About the only thing it can't debug is security errors due to a service running under a different account. It's pretty easy to track these errors down though. If the code works in debug mode, but fails when started as a service, then change the service startup account to use the same account you debugged with and restart the service. If the service works under this account, then you know you have a permissions issue. When debugging services I like to separate the code issues from security issues related to different accounts.