C# IO.ErrorEventArgs类代码示例

		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();
 }