private void watcherError(object sender, ErrorEventArgs e)
		{
			try
			{
				((FileSystemWatcher)sender).Dispose();

				FileSystemWatcher copy;

				lock (_sync)
				{
					if (_disposed)
						return;

					if (_watcher != sender)
						return;

					if (_watcher == null)
						return;

					copy = _watcher;
					_watcher = createWatch();
				}

				copy.EnableRaisingEvents = false;
				copy.Dispose();

				_are.Set();
			}
			catch (Exception ex)
			{
				throw new Exception("Error while file checking.", ex);
			}
		}

 protected virtual void OnError(ErrorEventArgs e)
 {
     if (Error != null)
     {
         Error(this, e);
     }
 }

        private void MjpegOnError(object sender, ErrorEventArgs e)
        {
            string message = string.Format(CultureInfo.InvariantCulture, "Cam error: {0}, restarting..", e.Message);
            _mainPage.DisplayStatus(message, MainPage.NotifyType.ErrorMessage);

            Task.Delay(TimeSpan.FromSeconds(1)).Wait();
            MjpegInitialize();
        }

 private void OnError(object sender, ErrorEventArgs e)
 {
     // Notify all cache entries on error.
     foreach (var token in _tokenCache.Values)
     {
         ReportChangeForMatchedEntries(token.Pattern);
     }
 }

 protected void OnNetworkStatusChanged(ErrorEventArgs e)
 {
     ErrorEventHandler handler = NetworkStatus;
     if (handler != null)
     {
         handler(this, e);
     }
 }

        private static void OnError(object sender, ErrorEventArgs e)
        {
            var exception = e.GetException();
            Console.Error.WriteLine($"Hit an Exception with HResult '{ exception.HResult }'" +
                Environment.NewLine +
                $"{ exception }");

            Environment.FailFast(exception.Message);
        }

 void OnError(object sender, ErrorEventArgs e)
 {
     // when an error occurs, the current FileSystemWatcher is disposed,
     // and a new one is created
     string lPath = fWatcher.Path;
     string lFilter = fWatcher.Filter;
     fWatcher.Dispose();
     Initialize(lPath, lFilter);
 }

        private static void ValidateErrorEventArgs(Exception exception)
        {
            ErrorEventArgs args = new ErrorEventArgs(exception);

            Assert.Equal(exception, args.GetException());

            // Make sure method is consistent.
            Assert.Equal(exception, args.GetException());
        }

 /// <summary>
 /// Initializes a new instance of the FileWatcherBufferErrorEventArgs class.
 /// </summary>
 /// <param name="daemonName">Daemon name of the file watcher.</param>
 /// <param name="e">ErrorEventArgs.</param>
 /// <exception cref="ArgumentNullException">e is null.</exception>
 /// <exception cref="ArgumentNullException">daemonName is null.</exception>
 public FileWatcherBufferErrorEventArgs(string daemonName,
     ErrorEventArgs e)
 {
     if (e == null)
     {
         throw new ArgumentNullException("e",
                                         Resources.ArgumentNullException);
     }
     if (daemonName == null)
     {
         throw new ArgumentNullException("daemonName",
                                         Resources.ArgumentNullException);
     }
     _daemonName = daemonName;
     _errorEventArgs = e;
 }

 private void pacServer_PACUpdateError(object sender, ErrorEventArgs e)
 {
     if (UpdatePACFromGFWListError != null)
         UpdatePACFromGFWListError(this, e);
 }

 private void PackReceived_Error(object sender, ErrorEventArgs e)
 {
     Terminal.Instance.Client.Notifier.Log(TraceLevel.Error, e.GetException().ToString());
 }

        /// <summary>
        /// Handles the Error event of the watcher control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ErrorEventArgs" /> instance containing the event data.</param>
        void watcher_Error(object sender, ErrorEventArgs e)
        {
            var ex = e.GetException();
            var dw = (FileSystemWatcher)sender;

            Logger.ErrorException("Error in Directory watcher for: " + dw.Path, ex);

            DisposeWatcher(dw);
        }

 /// <summary>
 ///     Callback for <see cref="FileSystemWatcher" /> file error events.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void OnFileError(object sender, ErrorEventArgs e)
 {
     _tailActor.Tell(new TailActor.FileError(_fileNameOnly, e.GetException().Message), ActorRefs.NoSender);
 }

        /// <summary>
        /// Handles the Error event of the watcher control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ErrorEventArgs" /> instance containing the event data.</param>
        void watcher_Error(object sender, ErrorEventArgs e)
        {
            var ex = e.GetException();
            var dw = (FileSystemWatcher)sender;

            Logger.ErrorException("Error in Directory watcher for: " + dw.Path, ex);

            DisposeWatcher(dw);

            if (ConfigurationManager.Configuration.EnableLibraryMonitor == AutoOnOff.Auto)
            {
                Logger.Info("Disabling realtime monitor to prevent future instability");

                ConfigurationManager.Configuration.EnableLibraryMonitor = AutoOnOff.Disabled;
                Stop();
            }
        }

 public void ReportErrors(ErrorEventArgs errorEventArguments) {
   throw new NotImplementedException();
 }

 private void OnError(object sender, ErrorEventArgs e)
 {
     // Trigger all the cache entries on error.
     foreach (var trigger in _triggerCache.Values)
     {
         ReportChangeForMatchedEntries(trigger.Pattern);
     }
 }

        /// <summary>
        /// Handles the Error event of the watcher control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ErrorEventArgs" /> instance containing the event data.</param>
        async void watcher_Error(object sender, ErrorEventArgs e)
        {
            var ex = e.GetException();
            var dw = (FileSystemWatcher)sender;

            Logger.ErrorException("Error in Directory watcher for: " + dw.Path, ex);

            //Network either dropped or, we are coming out of sleep and it hasn't reconnected yet - wait and retry
            var retries = 0;
            var success = false;
            while (!success && retries < 10)
            {
                await Task.Delay(500).ConfigureAwait(false);

                try
                {
                    dw.EnableRaisingEvents = false;
                    dw.EnableRaisingEvents = true;
                    success = true;
                }
                catch (ObjectDisposedException)
                {
                    RemoveWatcherFromList(dw);
                    return;
                }
                catch (IOException)
                {
                    Logger.Warn("Network still unavailable...");
                    retries++;
                }
                catch (ApplicationException)
                {
                    Logger.Warn("Network still unavailable...");
                    retries++;
                }
            }
            if (!success)
            {
                Logger.Warn("Unable to access network. Giving up.");
                DisposeWatcher(dw);
            }
        }

 // destructor shouldn't be used because it's not predictable when
 // it's going to be called by the GC!
 private void WorkTreeWatcherError(object sender, ErrorEventArgs e)
 {
     ScheduleNextRegularUpdate();
 }

        /// <summary>
        /// Handles the Error event of the <see cref="FileSystemWatcher"/>.
        /// </summary>
        private void OnFileWatcherError(object sender, ErrorEventArgs e)
        {
            // Stop further listening on error.
              if (mFileWatcher != null)
              {
            mFileWatcher.EnableRaisingEvents = false;
            mFileWatcher.Changed            -= OnLogFileChanged;
            mFileWatcher.Error              -= OnFileWatcherError;
            mFileWatcher.Dispose();
              }

              string pathOfFile = Path.GetDirectoryName(mFileToObserve);
              string nameOfFile = Path.GetFileName(mFileToObserve);

              if (!string.IsNullOrEmpty(pathOfFile) && !string.IsNullOrEmpty(nameOfFile))
              {
            mFileWatcher = new FileSystemWatcher(
            pathOfFile
              , nameOfFile);

            mFileWatcher.NotifyFilter        = NotifyFilters.LastWrite | NotifyFilters.Size;
            mFileWatcher.Changed            += OnLogFileChanged;
            mFileWatcher.Error              += OnFileWatcherError;
            mFileWatcher.EnableRaisingEvents = IsActive;

            ReadNewLogMessagesFromFile();
              }
        }

 private void GameManagerOnOnError(object sender, ErrorEventArgs errorEventArgs)
 {
     MessageBox.Show(errorEventArgs.GetException().ToString(), "Error creating game");
 }