GSF.ServiceProcess.ServiceHelper.Dispose C# (CSharp) Method

        protected override void Dispose(bool disposing)
        {
            if (m_disposed)
                return;

            try
            {
                // This will be done regardless of whether the object is finalized or disposed.
                if (!disposing)
                    return;

                // This will be done only when the object is disposed by calling Dispose().
                SaveSettings();

                if ((object)m_statusLog != null)
                {
                    m_statusLog.LogException -= StatusLog_LogException;
                    m_statusLog.Dispose();
                }

                if ((object)m_processScheduler != null)
                {
                    m_processScheduler.ScheduleDue -= Scheduler_ScheduleDue;
                    m_processScheduler.Dispose();
                }

                if ((object)m_errorLogger != null)
                {
                    m_errorLogger.LoggingException -= ErrorLogger_LoggingException;
                    m_errorLogger.Dispose();
                }

                if ((object)m_performanceMonitor != null)
                {
                    m_performanceMonitor.Dispose();
                }

                if ((object)m_remoteCommandProcess != null)
                {
                    m_remoteCommandProcess.ErrorDataReceived -= RemoteCommandProcess_ErrorDataReceived;
                    m_remoteCommandProcess.OutputDataReceived -= RemoteCommandProcess_OutputDataReceived;

                    if (!m_remoteCommandProcess.HasExited)
                        m_remoteCommandProcess.Kill();

                    m_remoteCommandProcess.Dispose();
                }

                if ((object)m_queueCancellationToken != null)
                    m_queueCancellationToken.Cancel();

                // Service processes are created and owned by remoting server, so we dispose them
                if ((object)m_processes != null)
                {
                    lock (m_processes)
                    {
                        foreach (ServiceProcess process in m_processes)
                        {
                            process.StateChanged -= Process_StateChanged;
                            process.Dispose();
                        }

                        m_processes.Clear();
                    }
                }

                // Detach any remoting server events, we don't own this component so we don't dispose it
                RemotingServer = null;
            }
            finally
            {
                m_disposed = true; // Prevent duplicate dispose.
                base.Dispose(disposing); // Call base class Dispose().
            }
        }