Handle non-critical exceptions

Author: sharwell

BasicSccProvider.csproj

@@ -116,6 +116,7 @@
     <Compile Include="Diff\View\DiffMarginControl.xaml.cs">
       <DependentUpon>DiffMarginControl.xaml</DependentUpon>
     </Compile>
+    <Compile Include="ExceptionExtensions.cs" />
     <Compile Include="GitToolCommands.cs" />
     <Compile Include="GitSccOptions.cs" />
     <Compile Include="PendingChangesView.xaml.cs">
@@ -142,6 +143,7 @@
     <Compile Include="SccProviderService.cs" />
     <Compile Include="PendingChangesToolWindow.cs" />
     <Compile Include="Schedulers\QueuedTaskScheduler.cs" />
+    <Compile Include="TaskExtensions.cs" />
     <Compile Include="UI\BranchPicker.xaml.cs">
       <DependentUpon>BranchPicker.xaml</DependentUpon>
     </Compile>

ExceptionExtensions.cs

@@ -0,0 +1,105 @@
+/* The MIT License
+ *
+ * Copyright (c) 2013 Sam Harwell, Tunnel Vision Labs, LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+namespace GitScc
+{
+    using System;
+    using System.Reflection;
+
+    public static class ExceptionExtensions
+    {
+        /// <summary>
+        /// Provides an <see cref="Action{Exception}"/> delegate wrapping the
+        /// <c>InternalPreserveStackTrace</c> method in the Microsoft .NET Framework.
+        /// </summary>
+        /// <remarks>
+        /// This initializer does not consider other frameworks (e.g. Mono), but
+        /// since this is part of a Visual Studio extension we know that the
+        /// Microsoft implementation is the one in use.
+        /// </remarks>
+        private static readonly Action<Exception> _internalPreserveStackTrace =
+            (Action<Exception>)Delegate.CreateDelegate(
+                typeof(Action<Exception>),
+                typeof(Exception).GetMethod(
+                    "InternalPreserveStackTrace",
+                    BindingFlags.Instance | BindingFlags.NonPublic));
+
+#pragma warning disable 618 // 'System.ExecutionEngineException' is obsolete
+        /// <summary>
+        /// Returns <c>true</c> if <paramref name="e"/> is considered a critical
+        /// exception, i.e. an exception which is likely to corrupt the process state
+        /// and unless <em>explicitly</em> handled should result in an application crash.
+        /// </summary>
+        /// <param name="e">The exception</param>
+        /// <returns><c>true</c> if <paramref name="e"/> is a critical exception,
+        /// otherwise <c>false</c>.</returns>
+        /// <exception cref="ArgumentNullException">if <paramref name="e"/> in <c>null</c>.</exception>
+        public static bool IsCritical(this Exception e)
+        {
+            if (e == null)
+                throw new ArgumentNullException("e");
+
+            if (e is AccessViolationException
+                || e is StackOverflowException
+                || e is ExecutionEngineException
+                || e is OutOfMemoryException
+                || e is BadImageFormatException
+                || e is AppDomainUnloadedException)
+            {
+                return true;
+            }
+
+            return false;
+        }
+#pragma warning restore 618
+
+        /// <summary>
+        /// This method ensures that the stack trace for <paramref name="e"/> is preserved
+        /// before a <c>rethrow</c> statement.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// In the Microsoft .NET Framework, if an exception is thrown, caught, and rethrown
+        /// all within the same method, by default the stack trace for the rethrown exception
+        /// will indicate that the exception was initially thrown at the location of the
+        /// <c>rethrow</c> statement. This method instructs the framework to instead
+        /// preserve the original stack trace when the exception is rethrown.
+        /// </para>
+        ///
+        /// <para>
+        /// This is the default behavior when an exception is caught and rethrown in a
+        /// <em>different</em> method from which it was originally thrown.
+        /// </para>
+        /// </remarks>
+        /// <param name="e">The exception</param>
+        /// <exception cref="ArgumentNullException">if <paramref name="e"/> in <c>null</c>.</exception>
+        public static void PreserveStackTrace(this Exception e)
+        {
+            if (e == null)
+                throw new ArgumentNullException("e");
+
+            _internalPreserveStackTrace(e);
+        }
+    }
+}

PendingChangesView.xaml.cs

@@ -121,7 +121,8 @@ private void dataGrid1_SelectionChanged(object sender, SelectionChangedEventArgs
                 }
             };
 
-            Task.Factory.StartNew(act, CancellationToken.None, TaskCreationOptions.LongRunning, SccProviderService.TaskScheduler);
+            Task.Factory.StartNew(act, CancellationToken.None, TaskCreationOptions.LongRunning, SccProviderService.TaskScheduler)
+                .HandleNonCriticalExceptions();
         }
 
         private void dataGrid1_MouseDoubleClick(object sender, MouseButtonEventArgs e)
@@ -317,7 +318,9 @@ internal void Refresh(GitFileStatusTracker tracker)
             };
 
             Task.Factory.StartNew(getChangedFiles, CancellationToken.None, TaskCreationOptions.LongRunning, SccProviderService.TaskScheduler)
-                .ContinueWith(continuationAction, TaskContinuationOptions.ExecuteSynchronously);
+                .HandleNonCriticalExceptions()
+                .ContinueWith(continuationAction, TaskContinuationOptions.ExecuteSynchronously)
+                .HandleNonCriticalExceptions();
         }
 
         internal void ClearUI()

SccProviderService.cs

@@ -679,7 +679,8 @@ internal void OpenTracker()
         private void HandleFileSystemChanged(object sender, FileSystemEventArgs e)
         {
             Action action = () => ProcessFileSystemChange(e);
-            Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.None, SccProviderService.TaskScheduler);
+            Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.None, SccProviderService.TaskScheduler)
+                .HandleNonCriticalExceptions();
         }
 
         private void ProcessFileSystemChange(FileSystemEventArgs e)
@@ -1092,7 +1093,9 @@ public void UpdateNodesGlyphs()
                 };
 
                 Task.Factory.StartNew(openTrackerAction, CancellationToken.None, TaskCreationOptions.LongRunning, SccProviderService.TaskScheduler)
-                    .ContinueWith(continuationAction, TaskContinuationOptions.ExecuteSynchronously);
+                    .HandleNonCriticalExceptions()
+                    .ContinueWith(continuationAction, TaskContinuationOptions.ExecuteSynchronously)
+                    .HandleNonCriticalExceptions();
             }
         }
 

TaskExtensions.cs

@@ -0,0 +1,73 @@
+/* The MIT License
+ *
+ * Copyright (c) 2013 Sam Harwell, Tunnel Vision Labs, LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+namespace GitScc
+{
+    using System;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    internal static class TaskExtensions
+    {
+        /// <summary>
+        /// This extension method ensures that any non-critical exception thrown during task
+        /// execution is handled before the task is cleaned up by the garbage collector.
+        /// </summary>
+        /// <typeparam name="T">The task type</typeparam>
+        /// <param name="task">The task</param>
+        /// <returns>Returns <paramref name="task"/>.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="task"/> is <code>null</code>.</exception>
+        public static T HandleNonCriticalExceptions<T>(this T task)
+            where T : Task
+        {
+            if (task == null)
+                throw new ArgumentNullException("task");
+
+            task.ContinueWith(HandleNonCriticalExceptionsCore, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
+            return task;
+        }
+
+        private static void HandleNonCriticalExceptionsCore(Task task)
+        {
+            if (task == null)
+                throw new ArgumentNullException("task");
+
+            AggregateException exception = task.Exception;
+            if (HasCriticalException(exception))
+                throw exception;
+        }
+
+        private static bool HasCriticalException(Exception exception)
+        {
+            if (exception == null)
+                throw new ArgumentNullException("exception");
+
+            AggregateException aggregate = exception as AggregateException;
+            if (aggregate != null)
+                return aggregate.InnerExceptions != null && aggregate.InnerExceptions.Any(HasCriticalException);
+
+            return exception.IsCritical();
+        }
+    }
+}