Why does ServiceBase.DeferredStop's catch() block call SetServiceStatus to revert the service-status to RUNNING when the process is doomed anyway?

[daiplusplus]

While doing research for my answer to this question on StackOverflow I noticed that in all versions of .NET (from .NET 8 going right back to .NET Framework 1.1), the ServiceBase class's DeferredStop method (or its equivalents in older versions) has a catch block that logs the exception and then re-throws (which will lead to the CLR termianting the process because DeferredStop runs in a CLR Thread Pool thread).

Currently (in .NET 8) it looks like this:

• BTW, despite the try{} block covering multiple statements (OnStop(), WriteLogEntry(), and SetServiceStatus()) - the catch seems like it's only prepared to catch exceptions thrown from OnStop - methinks that should be tweaked.
• Inside the catch block we see _status.currentState = previousState; - in this situation previousState will be either STATE_RUNNING or STATE_PAUSED.
• ...and then it calls SetServiceStatus(_statusHandle, pStatus); to inform SCM the service status has transitioned from STATE_STOP_PENDING to STATE_RUNNING or STATE_PAUSED.
• But this transition is invalid, according to SCM's documentation:: when stopping a service it will transition from STATE_RUNNING to STATE_STOP_PENDING and then to STATE_STOPPED. Once in STATE_STOP_PENDING the status cannot transition to any other state except STATE_STOPPED.
  • Though the SCM will "allow" invalid transitions by not raising an error, it's unclear if SCM will actually make the state-transition or not (I would test this myself but I'm not practically able-to right now).

So... why does it do something that it shouldn't need to and is quite clearly an invalid operation? (and not even any code-comments around it?)

    private unsafe void DeferredStop()
        {
            lock (_stopLock)
            {
                // never call SetServiceStatus again after STATE_STOPPED is set.
                if (_status.currentState != ServiceControlStatus.STATE_STOPPED)
                {
                    fixed (SERVICE_STATUS* pStatus = &_status)
                    {
                        int previousState = _status.currentState;

                        _status.checkPoint = 0;
                        _status.waitHint = 0;
                        _status.currentState = ServiceControlStatus.STATE_STOP_PENDING;
                        SetServiceStatus(_statusHandle, pStatus);
                        try
                        {
                            OnStop();
                            WriteLogEntry(SR.StopSuccessful);
                            _status.currentState = ServiceControlStatus.STATE_STOPPED;
                            SetServiceStatus(_statusHandle, pStatus);
                        }
                        catch (Exception e)
                        {
                            _status.currentState = previousState;
                            SetServiceStatus(_statusHandle, pStatus);
                            WriteLogEntry(SR.Format(SR.StopFailed, e), EventLogEntryType.Error);
                            throw;
                        }
                    }
                }
            }
        }

---

Should DeferredStop() be like this instead?

    private unsafe void DeferredStop() // This method runs in the CLR thread pool, and is kicked-off via `ThreadPool.QueueUserWorkItem(DeferredStop)` (previously `Delegate.BeginInvoke(DeferredStop)`)
        {
            lock (_stopLock)
            {
                // never call SetServiceStatus again after STATE_STOPPED is set.
                if (_status.currentState != ServiceControlStatus.STATE_STOPPED)
                {
                    fixed (SERVICE_STATUS* pStatus = &_status)
                    {
                        Debug.Assert( _status.currentState == ServiceControlStatus.STATE_RUNNING ||  _status.currentState == ServiceControlStatus.STATE_PAUSED );

                        int previousState = _status.currentState;

                        _status.checkPoint = 0;
                        _status.waitHint = 0;
                        _status.currentState = ServiceControlStatus.STATE_STOP_PENDING;
                        SetServiceStatus(_statusHandle, pStatus);

                        try
                        {
                            OnStop();
                        }
                        catch (Exception e)
                        {
                            WriteLogEntry(SR.Format(SR.StopFailed, e), EventLogEntryType.Error);
                            throw; // <-- Because this is a thread-pool method, this exception will never be handled and will cause the CLR to kill the entire process (right? but what if it only kills the thread but lets the process continue living, how does the SCM handle that?
                        }

                        WriteLogEntry(SR.StopSuccessful);
                        _status.currentState = ServiceControlStatus.STATE_STOPPED;
                        SetServiceStatus(_statusHandle, pStatus);
                    }
                }
            }
        }