/// <summary>
 /// Runs the given <seealso cref="Action"/> and handles all non-critical exceptions by showing an
 /// error dialog to the user. If the exception is critical, as determiend by <seealso cref="ErrorHandler.IsCriticalException(Exception)"/>
 /// then it is re-thrown as this could be that the process is not in a good state to continue executing.
 /// </summary>
 /// <param name="action"></param>
 public static void HandleExceptions(Action action)
 {
     try
     {
         action();
     }
     catch (AggregateException ex)
     {
         Debug.WriteLine($"Uncaught aggregate exception: {ex.Message}");
         if (ErrorHandler.ContainsCriticalException(ex))
         {
             throw;
         }
         EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
         UserPromptUtils.ExceptionPrompt(ex);
     }
     catch (Exception ex)
     {
         Debug.WriteLine($"Uncaught exception: {ex.Message}");
         if (ErrorHandler.IsCriticalException(ex))
         {
             throw;
         }
         EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
         UserPromptUtils.ExceptionPrompt(ex);
     }
 }
Esempio n. 2
0
#pragma warning disable VSTHRD100 // Avoid async void methods
        /// <summary>
        /// Runs the given <seealso cref="Task"/> and handles all non-critical exceptions by showing an
        /// error dialog to the user. If the exception is critical, as determined by
        /// <seealso cref="ErrorHandler.IsCriticalException(Exception)"/>, then it
        /// is re-thrown as this could be that the process is not in a good state to continue executing.
        /// </summary>
        /// <remarks>
        /// This method is intentionally async void, as it is meant to be the fire and forget method for tasks.
        /// </remarks>
        public static async void HandleExceptionsAsync(Func <Task> taskFunc)
        {
            try
            {
                await taskFunc();
            }
            catch (Exception ex) when(!IsCriticalException(ex))
            {
                EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
                UserPromptService.Default.ExceptionPrompt(ex);
            }
        }
Esempio n. 3
0
 /// <summary>
 /// Runs the given <seealso cref="Action"/> and handles all non-critical exceptions
 /// by showing an error dialog to the user.
 /// If the exception is critical, as determined by
 /// <seealso cref="ErrorHandler.IsCriticalException(Exception)"/>, then it
 /// is re-thrown as this could be that the process is not in a good state to continue executing.
 /// </summary>
 /// <param name="action"></param>
 public static void HandleExceptions(Action action)
 {
     try
     {
         action();
     }
     catch (Exception ex) when(!IsCriticalException(ex))
     {
         EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
         UserPromptService.Default.ExceptionPrompt(ex);
     }
 }
Esempio n. 4
0
        /// <summary>
        /// Runs the given <seealso cref="Task"/> and handles all non-critical exceptions by showing an
        /// error dialog to the user. If the exception is critical, as determiend by <seealso cref="ErrorHandler.IsCriticalException(Exception)"/>
        /// then it is re-thrown as this could be that the process is not in a good state to continue executing.
        /// </summary>
        public static async void HandleAsyncExceptions(Func <Task> task)
        {
            try
            {
                await task();
            }
            catch (Exception ex) when(!IsCriticalException(ex))
            {
                Debug.WriteLine($"Uncaught exception: {ex.Message}");

                EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
                UserPromptUtils.ExceptionPrompt(ex);
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Runs the given <seealso cref="Action"/> and handles all non-critical exceptions by showing an
        /// error dialog to the user. If the exception is critical, as determiend by <seealso cref="ErrorHandler.IsCriticalException(Exception)"/>
        /// then it is re-thrown as this could be that the process is not in a good state to continue executing.
        /// </summary>
        /// <param name="action"></param>
        public static void HandleExceptions(Action action)
        {
            try
            {
                action();
            }
            catch (Exception ex) when(!IsCriticalException(ex))
            {
                Debug.WriteLine($"Uncaught exception: {ex.Message}");

                EventsReporterWrapper.ReportEvent(UnhandledExceptionEvent.Create(ex));
                UserPromptUtils.ExceptionPrompt(ex);
            }
        }
Esempio n. 6
0
        /// <summary>
        ///     Broadcast the exception
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void _CurrentUnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
        {
            // we didn't come back from a broadcast
            if (_unhandled)
            {
                return;
            }

            _unhandled = true;

            var exception = new UnhandledExceptionEvent
            {
                Handled           = e.Handled,
                UncaughtException = e.ExceptionObject
            };

            EventAggregator.Publish(exception);
            e.Handled = exception.Handled;

            _unhandled = false;
        }
Esempio n. 7
0
        public static void ExceptionHandler()
        {
            var queue = new ManualEventQueue();

            // create subscriber
            UnhandledExceptionEvent lastEventHandled = null;
            var subscriber = DelegateEventHandler.OnException(evnt => lastEventHandled = evnt);

            queue.Subscribers.Add(subscriber);

            // enqueue and handle event
            queue.Enqueue(new UnhandledExceptionEvent(new UnauthorizedAccessException()));
            Assert.Null(lastEventHandled);
            Assert.True(queue.HandleNext());

            // test subscriber
            Assert.NotNull(lastEventHandled);
            Test.OrdinalEquals(lastEventHandled.Type, typeof(UnauthorizedAccessException).ToString());

            // queue is empty again (no unhandled exceptions or anything else)
            Assert.False(queue.HandleNext());
        }