Пример #1
0
 private void DisposeFileWatcher()
 {
     m_fileWatcher.Created -= m_fileProcessor.Watcher_Created;
     m_fileWatcher.Changed -= m_fileProcessor.Watcher_Changed;
     m_fileWatcher.Renamed -= m_fileProcessor.Watcher_Renamed;
     m_fileWatcher.Deleted -= m_fileProcessor.Watcher_Deleted;
     m_fileWatcher.Error   -= m_fileProcessor.Watcher_Error;
     m_fileWatcher.Dispose();
 }
Пример #2
0
        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="InterprocessCache"/> object and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    if (disposing)
                    {
                        if ((object)m_fileWatcher != null)
                        {
                            m_fileWatcher.Changed -= m_fileWatcher_Changed;
                            m_fileWatcher.Dispose();
                            m_fileWatcher = null;
                        }

                        if ((object)m_retryTimer != null)
                        {
                            m_retryTimer.Elapsed -= m_retryTimer_Elapsed;
                            m_retryTimer.Dispose();
                            m_retryTimer = null;
                        }

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

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

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

                        m_fileName = null;
                    }
                }
                finally
                {
                    m_disposed = true;  // Prevent duplicate dispose.
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Releases the unmanaged resources used by the file and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    // This will be done regardless of whether the object is finalized or disposed.
                    if (disposing)
                    {
                        // This will be done only when the object is disposed by calling Dispose().
                        Close();
                        SaveSettings();

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

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

                        if ((object)m_autoSaveTimer != null)
                        {
                            m_autoSaveTimer.Elapsed -= m_autoSaveTimer_Elapsed;
                            m_autoSaveTimer.Dispose();
                        }

                        if ((object)m_fileWatcher != null)
                        {
                            m_fileWatcher.Changed -= m_fileWatcher_Changed;
                            m_fileWatcher.Dispose();
                        }
                    }
                }
                finally
                {
                    m_disposed = true;          // Prevent duplicate dispose.

                    if (Disposed != null)
                    {
                        Disposed(this, EventArgs.Empty);
                    }
                }
            }
        }