internal bool OnCallbackException(Exception exception)
        {
            var args = new ExceptionEventArgs(exception);
            OnCallbackException(args);

            return args.Handled;
        }

 void FileLoader_GetFileAsTextFailed(object sender, ExceptionEventArgs e)
 {
     if (e.Exception != null)
         OnGetConnectionsFailed(new ExceptionEventArgs(e.Exception, e.UserState));
     else
         OnGetConnectionsFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionUnknownError), e.UserState));
 }

        protected void Arrange()
        {
            var random = new Random();
            _subsystemName = random.Next().ToString(CultureInfo.InvariantCulture);
            _operationTimeout = TimeSpan.FromSeconds(30);
            _encoding = Encoding.UTF8;
            _disconnectedRegister = new List<EventArgs>();
            _errorOccurredRegister = new List<ExceptionEventArgs>();
            _errorOccurredEventArgs = new ExceptionEventArgs(new SystemException());

            _sessionMock = new Mock<ISession>(MockBehavior.Strict);
            _channelMock = new Mock<IChannelSession>(MockBehavior.Strict);

            _sequence = new MockSequence();
            _sessionMock.InSequence(_sequence).Setup(p => p.CreateChannelSession()).Returns(_channelMock.Object);
            _channelMock.InSequence(_sequence).Setup(p => p.Open());
            _channelMock.InSequence(_sequence).Setup(p => p.SendSubsystemRequest(_subsystemName)).Returns(true);

            _subsystemSession = new SubsystemSessionStub(
                _sessionMock.Object,
                _subsystemName,
                _operationTimeout,
                _encoding);
            _subsystemSession.Disconnected += (sender, args) => _disconnectedRegister.Add(args);
            _subsystemSession.ErrorOccurred += (sender, args) => _errorOccurredRegister.Add(args);
            _subsystemSession.Connect();
        }

 protected virtual void OnException(ExceptionEventArgs e)
 {
     if (this.Exception != null)
     {
         this.Exception(this, e);
     }
 }

protected virtual void onThrowException(ExceptionEventArgs e)
{
    EventHandler<ExceptionEventArgs> handler = ThrowException;

            if(handler != null)
            {
                handler(this, e);
            }
}

        public void ExceptionEventArgs_Unit_BubbleException_True()
        {
            Exception exception = new ApplicationException("This is a test.").AsThrown();
            ExceptionEventArgs target = new ExceptionEventArgs(exception);
            Boolean value = true;

            target.BubbleException = value;
            Assert.AreEqual(value, target.BubbleException);
        }

        private void BitmapDownloadFailed(object sender, ExceptionEventArgs e)
        {
            var bitmap = (BitmapSource)sender;

            bitmap.DownloadCompleted -= BitmapDownloadCompleted;
            bitmap.DownloadFailed -= BitmapDownloadFailed;

            Image.Source = null;
        }

        private void BitmapDownloadFailed(object sender, ExceptionEventArgs e)
        {
            var bitmap = (BitmapSource)sender;

            bitmap.DownloadCompleted -= BitmapDownloadCompleted;
            bitmap.DownloadFailed -= BitmapDownloadFailed;

            ((MapImage)Children[currentImageIndex]).Source = null;
            BlendImages();
        }

        void bmp_DownloadFailed(object sender, ExceptionEventArgs e)
        {
            BitmapFrame bmp = (BitmapFrame)sender;
            var id = downloadingTiles[bmp];
            downloadingTiles.Remove(bmp);
            UnsubscribeBitmapEvents(bmp);
            bmp.Freeze();

            ReportFailure(id);
        }

 /// <summary>
 /// Handles non-fatal errors by writing a message describing the exception or
 /// failure to stderror.
 /// </summary>
 /// <param name="sender">Source of the error</param>
 /// <param name="e">Specifics of the exception or failure</param>
 internal static void OnNonFatalError(Object sender, ExceptionEventArgs e)
 {
     if (e.Exception != null)
     {
         Console.Error.WriteLine("Non-fatal exception: {0}", e.Exception.Message);
     }
     else
     {
         Console.Error.WriteLine("Non-fatal failure: {0}", e.Failure.Message);
     }
 }

 void FileLoader_FileLoadFailed(object sender, ExceptionEventArgs e)
 {
     if (e.Exception != null)
     {
         OnGetConfigurationStoreFailed(new ExceptionEventArgs(e.Exception, e.UserState));
     }
     else
     {
         OnGetConfigurationStoreFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionUnknownError), e.UserState));
     }
 }

 private static void LocalCrashHandler(object sender, ExceptionEventArgs args)
 {
     var exception = args.ErrorException;
     var recoverable = exception as RecoverableException;
     if(recoverable != null)
     {
         MessageDialog.ShowError(args.ErrorException.Message);
     }
     else
     {
         MessageDialog.ShowWarning(args.ErrorException.ToString());
     }           
 }

        public void ExceptionEventArgs_Integration_Serialization_Optimal()
        {
            Exception exception = new ApplicationException("This is a test.").AsThrown();
            Boolean bubbleException = true;
            ExceptionEventArgs original = new ExceptionEventArgs(exception, bubbleException);

            ExceptionEventArgs clone = original.SerializeBinary();
            Assert.AreNotSame(original, clone);
            Assert.AreEqual(original.BubbleException, clone.BubbleException);
            Assert.AreEqual(original.Exception.GetType(), clone.Exception.GetType());
            Assert.AreEqual(original.Exception.Message, clone.Exception.Message);
            Assert.AreEqual(original.Exception.StackTrace, clone.Exception.StackTrace);
        }

 protected virtual void OnBackgroundOpenReadAsyncFailed(ExceptionEventArgs args)
 {
     if (BackgroundOpenReadAsyncFailed != null)
     {
         if (ESRI.ArcGIS.Client.Extensibility.MapApplication.Current != null)
         {
             ESRI.ArcGIS.Client.Extensibility.MapApplication.Current.Dispatcher.BeginInvoke((Action)delegate
             {
                 BackgroundOpenReadAsyncFailed(this, args);
             });
         }
         else
             BackgroundOpenReadAsyncFailed(this, args);
     }
 }

        void SymbolConfigProvider_GetDefaultSymbolFailed(object sender, ExceptionEventArgs e)
        {
            GraphicsLayer layer = e.UserState as GraphicsLayer;
            if (layer == null)
                return;

            if (Core.LayerExtensions.GetRunLayerPostInitializationActions(layer))
            {
                PerformPostLayerInitializationActions(layer, true);
                Core.LayerExtensions.SetRunLayerPostInitializationActions(layer, false);
                return;
            }

            AddLayer(layer, true, null);
        }

 void FileLoader_FileLoadFailed(object sender, ExceptionEventArgs e)
 {
     object[] userState = (e.UserState as object[]);
     if (userState == null || userState.Length < 2)
         return;
     EventHandler<ExceptionEventArgs> onFailed = userState[2] as EventHandler<ExceptionEventArgs>;
     if (onFailed == null)
         return;
     if (e.Exception != null)
     {
         onFailed(this, new ExceptionEventArgs(e.Exception, userState[0]));
     }
     else
     {
         onFailed(this, new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionUnknownError), e.UserState));
     }
 }

 void Runtime_UnhandledException(object sender, ExceptionEventArgs args)
 {
     switch (args.Severity)
     {
         case ExceptionSeverityLevel.Info:
             EventLog.WriteEntry(args.Exception.ToString(), EventLogEntryType.Information);
             break;
         case ExceptionSeverityLevel.Warning:
             EventLog.WriteEntry(args.Exception.ToString(), EventLogEntryType.Warning);
             break;
         case ExceptionSeverityLevel.Error:
             EventLog.WriteEntry(args.Exception.ToString(), EventLogEntryType.Error);
             break;
         case ExceptionSeverityLevel.Fatal:
             EventLog.WriteEntry(args.Exception.ToString(), EventLogEntryType.FailureAudit);
             break;
     }
 }

		/// <summary> Sets up the eviroment and raises user events </summary>
		internal void RaisePausedEvents()
		{
			AssertPaused();
			DisableAllSteppers();
			CheckSelectedStackFrames();
			SelectMostRecentStackFrameWithLoadedSymbols();
			
			if (this.PauseSession.PausedReason == PausedReason.Exception) {
				ExceptionEventArgs args = new ExceptionEventArgs(this, this.SelectedThread.CurrentException, this.SelectedThread.CurrentExceptionType, this.SelectedThread.CurrentExceptionIsUnhandled);
				OnExceptionThrown(args);
				// The event could have resumed or killed the process
				if (this.IsRunning || this.TerminateCommandIssued || this.HasExited) return;
			}
			
			while(BreakpointHitEventQueue.Count > 0) {
				Breakpoint breakpoint = BreakpointHitEventQueue.Dequeue();
				breakpoint.NotifyHit();
				// The event could have resumed or killed the process
				if (this.IsRunning || this.TerminateCommandIssued || this.HasExited) return;
			}
			
			OnPaused();
			// The event could have resumed the process
			if (this.IsRunning || this.TerminateCommandIssued || this.HasExited) return;
		}

		protected internal virtual void OnExceptionThrown(ExceptionEventArgs e)
		{
			TraceMessage ("Debugger event: OnExceptionThrown()");
			if (ExceptionThrown != null) {
				ExceptionThrown(this, e);
			}
		}

 private void Session_ErrorOccured(object sender, ExceptionEventArgs e)
 {
     this.RaiseError(e.Exception);
 }