Use InvokeAsyncAndForget() instead of InvokeAsync().FireAndForget().

src/AddIns/Analysis/UnitTesting/TestRunner/TestExecutionManager.cs

@@ -163,7 +163,9 @@ namespace ICSharpCode.UnitTesting.Frameworks
 		
 		void testRunner_TestFinished(object sender, TestFinishedEventArgs e)
 		{
-			mainThread.InvokeAsync(delegate { ShowResult(e.Result); }).FireAndForget();
+			mainThread.InvokeAsyncAndForget(delegate {
+				ShowResult(e.Result);
+			});
 		}
 		
 		protected void ShowResult(TestResult result)

src/AddIns/BackendBindings/FSharpBinding/FSharpInteractive.cs

@@ -71,21 +71,21 @@ namespace FSharpBinding
 					lock (outputQueue) {
 						outputQueue.Enqueue(e.Data);
 					}
-					SD.MainThread.InvokeAsync(ReadAll).FireAndForget();
+					SD.MainThread.InvokeAsyncAndForget(ReadAll);
 				};
 				fsiProcess.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e) {
 					lock (outputQueue) {
 						outputQueue.Enqueue(e.Data);
 					}
-					SD.MainThread.InvokeAsync(ReadAll).FireAndForget();
+					SD.MainThread.InvokeAsyncAndForget(ReadAll);
 				};
 				fsiProcess.Exited += delegate(object sender, EventArgs e) {
 					lock (outputQueue) {
 						outputQueue.Enqueue("fsi.exe died");
 						outputQueue.Enqueue("restarting ...");
 					}
-					SD.MainThread.InvokeAsync(ReadAll).FireAndForget();
-					SD.MainThread.InvokeAsync(StartFSharp).FireAndForget();
+					SD.MainThread.InvokeAsyncAndForget(ReadAll);
+					SD.MainThread.InvokeAsyncAndForget(StartFSharp);
 				};
 				StartFSharp();
 			}

src/AddIns/Debugger/Debugger.AddIn/Service/WindowsDebugger.cs

@@ -464,7 +464,7 @@ namespace ICSharpCode.SharpDevelop.Services
 			} catch (GetValueException e) {
 				string errorMessage = "Error while evaluating breakpoint condition " + code + ":\n" + e.Message + "\n";
 				DebuggerService.PrintDebugMessage(errorMessage);
-				SD.MainThread.InvokeAsync(() => MessageService.ShowWarning(errorMessage)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => MessageService.ShowWarning(errorMessage));
 				return true;
 			}
 		}

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/NewLineConsistencyCheck.cs

@@ -62,7 +62,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 			// don't allow mac-style newlines; accept either unix or windows-style newlines but avoid mixing them
 			bool isConsistent = (numCR == 0) && (numLF == 0 || numCRLF == 0);
 			if (!isConsistent) {
-				SD.MainThread.InvokeAsync(() => ShowInconsistentWarning(numLF > numCRLF)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => ShowInconsistentWarning(numLF > numCRLF));
 			}
 		}
 		

src/AddIns/DisplayBindings/ILSpyAddIn/ViewContent/DecompiledViewContent.cs

@@ -133,7 +133,7 @@ namespace ICSharpCode.ILSpyAddIn
 				StringWriter writer = new StringWriter();
 				RunDecompiler(assemblyFile, fullTypeName, new DebuggerTextOutput(new PlainTextOutput(writer)), cancellation.Token);
 				if (!cancellation.IsCancellationRequested) {
-					SD.MainThread.InvokeAsync(() => OnDecompilationFinished(writer)).FireAndForget();
+					SD.MainThread.InvokeAsyncAndForget(() => OnDecompilationFinished(writer));
 				}
 			} catch (OperationCanceledException) {
 				// ignore cancellation
@@ -148,7 +148,7 @@ namespace ICSharpCode.ILSpyAddIn
 				writer.WriteLine(string.Format("Exception while decompiling {0} ({1})", fullTypeName, assemblyFile));
 				writer.WriteLine();
 				writer.WriteLine(ex.ToString());
-				SD.MainThread.InvokeAsync(() => OnDecompilationFinished(writer)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => OnDecompilationFinished(writer));
 			}
 		}
 		

src/AddIns/DisplayBindings/IconEditor/IconViewContent.cs

@@ -39,12 +39,12 @@ namespace ICSharpCode.IconEditor
 			} catch (InvalidIconException ex) {
 				// call with a delay to work around a re-entrancy bug
 				// when closing a workbench window while it is getting activated
-				SD.MainThread.InvokeAsync(delegate {
+				SD.MainThread.InvokeAsyncAndForget(delegate {
 					MessageService.ShowHandledException(ex);
 					if (WorkbenchWindow != null) {
 						WorkbenchWindow.CloseWindow(true);
 					}
-				}).FireAndForget();
+				});
 			}
 		}
 		

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/Commands/Pads.cs

@@ -3,6 +3,7 @@
 
 using System;
 using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.WpfDesign.AddIn.Commands
@@ -14,7 +15,7 @@ namespace ICSharpCode.WpfDesign.AddIn.Commands
     {
         public override void Run()
         {
-            WorkbenchSingleton.Workbench.GetPad(typeof(ToolsPad)).BringPadToFront();
+            SD.Workbench.GetPad(typeof(ToolsPad)).BringPadToFront();
         }
     }
 	
@@ -25,7 +26,7 @@ namespace ICSharpCode.WpfDesign.AddIn.Commands
     {
         public override void Run()
         {
-            WorkbenchSingleton.Workbench.GetPad(typeof(PropertyPad)).BringPadToFront();
+            SD.Workbench.GetPad(typeof(PropertyPad)).BringPadToFront();
         }
     }
 	
@@ -36,7 +37,7 @@ namespace ICSharpCode.WpfDesign.AddIn.Commands
     {
         public override void Run()
         {
-            WorkbenchSingleton.Workbench.GetPad(typeof(OutlinePad)).BringPadToFront();
+            SD.Workbench.GetPad(typeof(OutlinePad)).BringPadToFront();
         }
     }
 }

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/Commands/ViewXaml.cs

@@ -3,7 +3,7 @@
 
 using System;
 using ICSharpCode.Core;
-using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.SharpDevelop;
 
 namespace ICSharpCode.WpfDesign.AddIn.Commands
 {
@@ -14,7 +14,7 @@ namespace ICSharpCode.WpfDesign.AddIn.Commands
 	{
 		public override void Run()
 		{
-			WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.SwitchView(0);
+			SD.Workbench.ActiveWorkbenchWindow.SwitchView(0);
 		}
 	}
 }

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/ImageSourceEditor/ImageSourceEditor.xaml.cs

@@ -8,7 +8,7 @@ using System.Windows.Markup;
 using System.Windows.Media;
 
 using ICSharpCode.Core;
-using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.SharpDevelop;
 using ICSharpCode.WpfDesign.PropertyGrid;
 
 namespace ICSharpCode.WpfDesign.AddIn.ImageSourceEditor
@@ -40,7 +40,7 @@ namespace ICSharpCode.WpfDesign.AddIn.ImageSourceEditor
 			}
 			ChooseImageDialog cid = new ChooseImageDialog();
 			cid.SelectedFileName = fileName;
-			cid.Owner = WorkbenchSingleton.MainWindow;
+			cid.Owner = SD.Workbench.MainWindow;
 			if (cid.ShowDialog() == true) {
 				fileName = cid.SelectedFileName;
 				if (fileName == null) {

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/WpfDocumentError.xaml.cs

@@ -5,7 +5,7 @@ using System;
 using System.Windows;
 using System.Windows.Controls;
 
-using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.SharpDevelop;
 
 namespace ICSharpCode.WpfDesign.AddIn
 {
@@ -25,7 +25,7 @@ namespace ICSharpCode.WpfDesign.AddIn
 		
 		void ViewXaml(object sender,RoutedEventArgs e)
 		{
-			WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.SwitchView(0);
+			SD.Workbench.ActiveWorkbenchWindow.SwitchView(0);
 		}
 	}
 }

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/WpfToolbox.cs

@@ -2,10 +2,10 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using System.Diagnostics;
 using System.Windows.Forms;
 
 using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Gui;
 using ICSharpCode.SharpDevelop.Widgets.SideBar;
 using WPF = System.Windows.Controls;
@@ -21,7 +21,7 @@ namespace ICSharpCode.WpfDesign.AddIn
 		
 		public static WpfToolbox Instance {
 			get {
-				WorkbenchSingleton.AssertMainThread();
+				SD.MainThread.VerifyAccess();
 				if (instance == null) {
 					instance = new WpfToolbox();
 				}

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/WpfViewContent.cs

@@ -150,7 +150,7 @@ namespace ICSharpCode.WpfDesign.AddIn
 			}
 			
 			if (xamlErrorService.Errors.Count != 0) {
-				WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
+				SD.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
 			}
 		}
 		

src/AddIns/Misc/SearchAndReplace/Project/Gui/SearchAndReplacePanel.cs

@@ -109,7 +109,7 @@ namespace SearchAndReplace
 				return;
 			}
 			// No using block for the monitor; it is disposed when the asynchronous search finishes
-			var monitor = WorkbenchSingleton.StatusBar.CreateProgressMonitor();
+			var monitor = SD.StatusBar.CreateProgressMonitor();
 			monitor.TaskName = StringParser.Parse("${res:AddIns.SearchReplace.SearchProgressTitle}");
 			var results = SearchManager.FindAllParallel(strategy, location, monitor);
 			SearchManager.ShowSearchResults(SearchOptions.FindPattern, results);
@@ -127,7 +127,7 @@ namespace SearchAndReplace
 				return;
 			}
 			// No using block for the monitor; it is disposed when the asynchronous search finishes
-			var monitor = WorkbenchSingleton.StatusBar.CreateProgressMonitor();
+			var monitor = SD.StatusBar.CreateProgressMonitor();
 			monitor.TaskName = StringParser.Parse("${res:AddIns.SearchReplace.SearchProgressTitle}");
 			var results = SearchManager.FindAllParallel(strategy, location, monitor);
 			SearchManager.MarkAll(results);

src/AddIns/Misc/StartPage/Project/Src/RecentProjectsControl.xaml.cs

@@ -64,10 +64,10 @@ namespace ICSharpCode.StartPage
 				}
 			}
 			if (items.Count > 0) {
-				SD.MainThread.InvokeAsync(new Action(delegate {
+				SD.MainThread.InvokeAsyncAndForget(new Action(delegate {
 					lastProjectsListView.ItemsSource = items;
 					lastProjectsListView.Visibility = Visibility.Visible;
-				})).FireAndForget();
+				}));
 			}
 		}
 		

src/AddIns/VersionControl/GitAddIn/Src/GitGuiWrapper.cs

@@ -74,7 +74,7 @@ namespace ICSharpCode.GitAddIn
 					p.Exited += delegate {
 						p.Dispose();
 						if (callback != null) {
-							SD.MainThread.InvokeAsync(callback).FireAndForget();
+							SD.MainThread.InvokeAsyncAndForget(callback);
 						}
 					};
 //					p.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e) {

src/AddIns/VersionControl/GitAddIn/Src/OverlayIconManager.cs

@@ -130,7 +130,7 @@ namespace ICSharpCode.GitAddIn
 				}
 			}
 			
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				Image image = GetImage(status);
 				if (image != null) {
 					node.Overlay = image;
@@ -139,7 +139,7 @@ namespace ICSharpCode.GitAddIn
 					// reset overlay to null only if the old overlay belongs to the OverlayIconManager
 					node.Overlay = null;
 				}
-			}).FireAndForget();
+			});
 		}
 		
 		public static Image GetImage(GitStatus status)

src/AddIns/VersionControl/GitAddIn/Src/RegisterEventsCommand.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.GitAddIn
 		void AddFile(string fileName)
 		{
 			Git.Add(fileName,
-				exitcode => SD.MainThread.InvokeAsync(() => ClearStatusCacheAndEnqueueFile(fileName)).FireAndForget()
+				exitcode => SD.MainThread.InvokeAsyncAndForget(() => ClearStatusCacheAndEnqueueFile(fileName))
 			);
 		}
 		
@@ -43,16 +43,16 @@ namespace ICSharpCode.GitAddIn
 		{
 			if (GitStatusCache.GetFileStatus(fileName) == GitStatus.Added) {
 				Git.Remove(fileName, true,
-					exitcode => SD.MainThread.InvokeAsync(() => ClearStatusCacheAndEnqueueFile(fileName)).FireAndForget());
+					exitcode => SD.MainThread.InvokeAsyncAndForget(() => ClearStatusCacheAndEnqueueFile(fileName)));
 			}
 		}
 		
 		void RenameFile(string sourceFileName, string targetFileName)
 		{
 			Git.Add(targetFileName,
-				exitcode => SD.MainThread.InvokeAsync(() => RemoveFile(sourceFileName)).FireAndForget()
+				exitcode => SD.MainThread.InvokeAsyncAndForget(() => RemoveFile(sourceFileName))
 			);
-			SD.MainThread.InvokeAsync(() => ClearStatusCacheAndEnqueueFile(targetFileName)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => ClearStatusCacheAndEnqueueFile(targetFileName));
 		}
 		
 		void TreeNodeCreated(object sender, TreeViewEventArgs e)

src/AddIns/VersionControl/SubversionAddIn/Src/Commands/ProjectBrowserCommands.cs

@@ -135,7 +135,7 @@ namespace ICSharpCode.Svn.Commands
 			
 			public void Callback()
 			{
-				SD.MainThread.InvokeAsync(CallbackInvoked).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(CallbackInvoked);
 			}
 			
 			void CallbackInvoked()

src/AddIns/VersionControl/SubversionAddIn/Src/Gui/HistoryViewDisplayBinding/HistoryViewPanel.cs

@@ -99,7 +99,7 @@ namespace ICSharpCode.Svn
 				// if exceptions aren't caught here, they force SD to exit
 				if (ex is SvnClientException || ex is System.Runtime.InteropServices.SEHException) {
 					LoggingService.Warn(ex);
-					SD.MainThread.InvokeAsync(() => infoPanel.ShowError(ex)).FireAndForget();
+					SD.MainThread.InvokeAsyncAndForget(() => infoPanel.ShowError(ex));
 				} else {
 					MessageService.ShowException(ex);
 				}
@@ -109,7 +109,7 @@ namespace ICSharpCode.Svn
 		void ReceiveLogMessage(LogMessage logMessage)
 		{
 			if (infoPanel != null) {
-				SD.MainThread.InvokeAsync(() => infoPanel.AddLogMessage(logMessage)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => infoPanel.AddLogMessage(logMessage));
 			}
 //			if (diffPanel != null) {
 //				WorkbenchSingleton.SafeThreadAsyncCall(diffPanel.AddLogMessage, logMessage);

src/AddIns/VersionControl/SubversionAddIn/Src/Gui/HistoryViewDisplayBinding/InfoPanel.cs

@@ -158,7 +158,7 @@ namespace ICSharpCode.Svn
 				}
 				loadChangedPathsItem = null;
 				isLoadingChangedPaths = false;
-				SD.MainThread.InvokeAsync(() => this.RevisionListViewSelectionChanged(null, EventArgs.Empty)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => this.RevisionListViewSelectionChanged(null, EventArgs.Empty));
 			} catch (Exception ex) {
 				MessageService.ShowException(ex);
 			}
@@ -171,7 +171,7 @@ namespace ICSharpCode.Svn
 		
 		void ReceiveAllChangedPaths(LogMessage logMessage)
 		{
-			SD.MainThread.InvokeAsync(() => this.ReceiveAllChangedPathsInvoked(logMessage)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => this.ReceiveAllChangedPathsInvoked(logMessage));
 		}
 		
 		void ReceiveAllChangedPathsInvoked(LogMessage logMessage)

src/AddIns/VersionControl/SubversionAddIn/Src/Gui/ProjectBrowserVisitor/OverlayIconManager.cs

@@ -184,7 +184,7 @@ namespace ICSharpCode.Svn
 						client = new SvnClientWrapper();
 					} catch (Exception ex) {
 						subversionDisabled = true;
-						SD.MainThread.InvokeAsync(() => MessageService.ShowWarning("Error initializing Subversion library:\n" + ex.ToString())).FireAndForget();
+						SD.MainThread.InvokeAsyncAndForget(() => MessageService.ShowWarning("Error initializing Subversion library:\n" + ex.ToString()));
 						return StatusKind.None;
 					}
 				}
@@ -220,9 +220,9 @@ namespace ICSharpCode.Svn
 				}
 			}
 			
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				node.Overlay = GetImage(status);
-			}).FireAndForget();
+			});
 		}
 	}
 }

src/Main/Base/Project/Designer/TypeResolutionService.cs

@@ -244,7 +244,7 @@ namespace ICSharpCode.SharpDevelop.Designer
 						// The error might be caused by an assembly that is
 						// not even needed for the designer to load.
 						LoggingService.Error("Error loading assembly " + fileName, e);
-						WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
+						SD.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
 						TaskService.BuildMessageViewCategory.AppendText(
 							StringParser.Parse("${res:FileUtilityService.ErrorWhileLoading}")
 							+ "\r\n" + fileName + "\r\n" + e.Message + "\r\n"

src/Main/Base/Project/Src/Commands/MenuItemBuilders.cs

@@ -261,11 +261,11 @@ namespace ICSharpCode.SharpDevelop.Commands
 
 		void ProcessExitEvent(object sender, EventArgs e)
 		{
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				ProcessRunner p = (ProcessRunner)sender;
 				TaskService.BuildMessageViewCategory.AppendLine(StringParser.Parse("${res:XML.MainMenu.ToolMenu.ExternalTools.ExitedWithCode} " + p.ExitCode));
 				p.Dispose();
-			}).FireAndForget();
+			});
 		}
 		
 		void process_OutputLineReceived(object sender, LineReceivedEventArgs e)

src/Main/Base/Project/Src/Gui/Components/LocalizedPropertyGrid/LocalizedObject.cs

@@ -70,9 +70,9 @@ namespace ICSharpCode.SharpDevelop.Gui
 		{
 			globalizedProps = null;
 			if (SD.Workbench != null) {
-				SD.MainThread.InvokeAsync(delegate {
+				SD.MainThread.InvokeAsyncAndForget(delegate {
 					PropertyPad.RefreshItem(this);
-				}).FireAndForget();
+				});
 			}
 		}
 		

src/Main/Base/Project/Src/Gui/Dialogs/ReferenceDialog/GacReferencePanel.cs

@@ -274,7 +274,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 			
 			MSBuildInternals.ResolveAssemblyReferences(project, referenceItems.ToArray(), resolveOnlyAdditionalReferences: true, logErrorsToOutputPad: false);
 			
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				if (IsDisposed) {
 					return;
 				}
@@ -283,7 +283,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 						itemsToResolveVersion [i].SubItems [1].Text = referenceItems [i].Version.ToString();
 					}
 				}
-			}).FireAndForget();
+			});
 		}
 		
 		#if DEBUG

src/Main/Base/Project/Src/Gui/Dialogs/ReferenceDialog/ServiceReference/SvcUtilRunner.cs

@@ -67,7 +67,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Dialogs.ReferenceDialog.ServiceReference
 			var runner = (ProcessRunner)sender;
 			ExitCode = runner.ExitCode;
 			
-			SD.MainThread.InvokeAsync(() => OnProcessExited()).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => OnProcessExited());
 		}
 		
 		void OnProcessExited()

src/Main/Base/Project/Src/Gui/Pads/CompilerMessageView/CompilerMessageView.cs

@@ -265,7 +265,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		public void AddCategory(MessageViewCategory category)
 		{
 			if (SD.MainThread.InvokeRequired) {
-				SD.MainThread.InvokeAsync(() => AddCategory(category)).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(() => AddCategory(category));
 				return;
 			}
 			messageCategories.Add(category);
@@ -307,8 +307,9 @@ namespace ICSharpCode.SharpDevelop.Gui
 			bool waitForMainThread;
 			lock (appendLock) {
 				appendCalls.Add(appendCall);
-				if (appendCalls.Count == 1)
-					SD.MainThread.InvokeAsync(ProcessAppendText).FireAndForget();
+				if (appendCalls.Count == 1) {
+					SD.MainThread.InvokeAsyncAndForget(ProcessAppendText);
+				}
 				waitForMainThread = appendCalls.Count > 2000;
 			}
 			if (waitForMainThread && SD.MainThread.InvokeRequired) {

src/Main/Base/Project/Src/Gui/Pads/FileScout.cs

@@ -159,7 +159,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 					}
 				}
 			};
-			SD.MainThread.InvokeAsync(method).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(method);
 		}
 		
 		void fileChanged(object sender, FileSystemEventArgs e)
@@ -181,7 +181,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 					}
 				}
 			};
-			SD.MainThread.InvokeAsync(method).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(method);
 		}
 		
 		void fileCreated(object sender, FileSystemEventArgs e)
@@ -197,7 +197,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 					// ignore IO errors
 				}
 			};
-			SD.MainThread.InvokeAsync(method).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(method);
 		}
 		
 		void fileRenamed(object sender, RenamedEventArgs e)
@@ -212,7 +212,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 					}
 				}
 			};
-			SD.MainThread.InvokeAsync(method).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(method);
 		}
 		
 		void renameFile(object sender, EventArgs e)

src/Main/Base/Project/Src/Gui/Pads/ProjectBrowser/ProjectBrowserPad.cs

@@ -151,7 +151,7 @@ namespace ICSharpCode.SharpDevelop.Project
 			// do the potentially expensive selection of the item in the tree view only once after the last change
 			if (!activeContentChangedEnqueued) {
 				activeContentChangedEnqueued = true;
-				SD.MainThread.InvokeAsync(ActiveContentChangedInvoked).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(ActiveContentChangedInvoked);
 			}
 		}
 		
@@ -266,10 +266,10 @@ namespace ICSharpCode.SharpDevelop.Project
 			if (refreshViewEnqueued || instance == null)
 				return;
 			refreshViewEnqueued = true;
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				refreshViewEnqueued = false;
 				instance.ProjectBrowserControl.RefreshView();
-			}).FireAndForget();
+			});
 		}
 	}
 }

src/Main/Base/Project/Src/Project/CompilableProject.cs

@@ -393,12 +393,12 @@ namespace ICSharpCode.SharpDevelop.Project
 				c.ParseInformationUpdated(args.OldUnresolvedFile, args.NewUnresolvedFile);
 			// OnParseInformationUpdated is called inside a lock, but we don't want to raise the event inside that lock.
 			// To ensure events are raised in the same order, we always invoke on the main thread.
-			SD.MainThread.InvokeAsync(
-				delegate {
-					if (typeDefinitionModels != null)
-						typeDefinitionModels.Update(args.OldUnresolvedFile, args.NewUnresolvedFile);
-					ParseInformationUpdated(null, args);
-				}).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(delegate {
+				if (typeDefinitionModels != null) {
+					typeDefinitionModels.Update(args.OldUnresolvedFile, args.NewUnresolvedFile);
+				}
+				ParseInformationUpdated(null, args);
+			});
 		}
 		
 		public override event EventHandler<ParseInformationEventArgs> ParseInformationUpdated = delegate {};

src/Main/Base/Project/Src/Project/CustomTool.cs

@@ -208,7 +208,7 @@ namespace ICSharpCode.SharpDevelop.Project
 		{
 			RunAsync(delegate {
 			         	CodeCompileUnit ccu = func();
-			         	SD.MainThread.InvokeAsync(() => WriteCodeDomToFile(baseItem, outputFileName, ccu)).FireAndForget();
+			         	SD.MainThread.InvokeAsyncAndForget(() => WriteCodeDomToFile(baseItem, outputFileName, ccu));
 			         });
 		}
 		
@@ -485,7 +485,7 @@ namespace ICSharpCode.SharpDevelop.Project
 		
 		internal static void NotifyAsyncFinish(CustomToolContext context)
 		{
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				activeToolRun = null;
 				if (toolRuns.Count > 0) {
 					CustomToolRun nextRun = toolRuns.Dequeue();
@@ -493,7 +493,7 @@ namespace ICSharpCode.SharpDevelop.Project
 						RunCustomTool(nextRun);
 					}
 				}
-			}).FireAndForget();
+			});
 		}
 	}
 	#endregion

src/Main/Base/Project/Src/Services/Debugger/CurrentLineBookmark.cs

@@ -120,9 +120,9 @@ namespace ICSharpCode.SharpDevelop.Debugging
 		{
 			// call async because the Debugger seems to use Application.DoEvents(), but we don't want to process events
 			// because Drag'N'Drop operation has finished
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				DebuggerService.CurrentDebugger.SetInstructionPointer(this.FileName, lineNumber, 1, false);
-			}).FireAndForget();
+			});
 		}
 	}
 }

src/Main/Base/Project/Src/Services/Debugger/DefaultDebugger.cs

@@ -73,7 +73,7 @@ namespace ICSharpCode.SharpDevelop.Debugging
 			attachedProcess.Exited -= new EventHandler(AttachedProcessExited);
 			attachedProcess.Dispose();
 			attachedProcess = null;
-			SD.MainThread.InvokeAsync(() => new Action<EventArgs>(OnDebugStopped)(EventArgs.Empty)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => new Action<EventArgs>(OnDebugStopped)(EventArgs.Empty));
 		}
 		
 		public void StartWithoutDebugging(ProcessStartInfo processStartInfo)

src/Main/Base/Project/Workbench/WorkbenchSingleton.cs

@@ -184,7 +184,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		[Obsolete("Use SD.MainThread.InvokeAsync().FireAndForget() instead")]
 		public static void SafeThreadAsyncCall(Action method)
 		{
-			SD.MainThread.InvokeAsync(method).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(method);
 		}
 		
 		/// <summary>
@@ -193,7 +193,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		[Obsolete("Use SD.MainThread.InvokeAsync().FireAndForget() instead")]
 		public static void SafeThreadAsyncCall<A>(Action<A> method, A arg1)
 		{
-			SD.MainThread.InvokeAsync(() => method(arg1)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => method(arg1));
 		}
 		
 		/// <summary>
@@ -202,7 +202,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		[Obsolete("Use SD.MainThread.InvokeAsync().FireAndForget() instead")]
 		public static void SafeThreadAsyncCall<A, B>(Action<A, B> method, A arg1, B arg2)
 		{
-			SD.MainThread.InvokeAsync(() => method(arg1, arg2)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => method(arg1, arg2));
 		}
 		
 		/// <summary>
@@ -211,7 +211,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		[Obsolete("Use SD.MainThread.InvokeAsync().FireAndForget() instead")]
 		public static void SafeThreadAsyncCall<A, B, C>(Action<A, B, C> method, A arg1, B arg2, C arg3)
 		{
-			SD.MainThread.InvokeAsync(() => method(arg1, arg2, arg3)).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(() => method(arg1, arg2, arg3));
 		}
 		
 		/// <summary>

src/Main/SharpDevelop/Parser/LoadSolutionProjects.cs

@@ -50,11 +50,10 @@ namespace ICSharpCode.SharpDevelop.Parser
 		{
 			if (threadRunningTime != null)
 				LoggingService.Debug("LoadSolutionProjectsThread finished after " + threadRunningTime.Elapsed);
-			SD.MainThread.InvokeAsync(
-				delegate {
-					IsRunning = false;
-					Finished(this, EventArgs.Empty);
-				}).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(delegate {
+				IsRunning = false;
+				Finished(this, EventArgs.Empty);
+			});
 		}
 		
 		static string GetLoadReferenceTaskTitle(string projectName)
@@ -83,7 +82,7 @@ namespace ICSharpCode.SharpDevelop.Parser
 			jobs.AddJob(new JobTask(action, name, cost));
 			// Start the thread with a bit delay so that the SD UI gets responsive first,
 			// and so that the total cost is known for showing the progress bar.
-			SD.MainThread.InvokeAsync(jobs.StartRunningIfRequired, DispatcherPriority.Background).FireAndForget();
+			SD.MainThread.InvokeAsyncAndForget(jobs.StartRunningIfRequired, DispatcherPriority.Background);
 		}
 		
 		public void CancelAllJobs()
@@ -163,7 +162,7 @@ namespace ICSharpCode.SharpDevelop.Parser
 							if (actions.Count > 0) {
 								actions.Dequeue(); // dequeue the null
 								if (actions.Count > 0)
-									SD.MainThread.InvokeAsync(StartRunningIfRequired).FireAndForget();
+									SD.MainThread.InvokeAsyncAndForget(StartRunningIfRequired);
 								else
 									loadSolutionProjects.RaiseThreadEnded();
 							} else {

src/Main/SharpDevelop/Parser/ParserService.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.SharpDevelop.Parser
 		{
 			// RaiseParseInformationUpdated is called inside a lock, but we don't want to raise the event inside that lock.
 			// To ensure events are raised in the same order, we always invoke on the main thread.
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				if (!LoadSolutionProjectsThread.IsRunning) {
 					string addition;
 					if (e.OldUnresolvedFile == null) {
@@ -53,7 +53,7 @@ namespace ICSharpCode.SharpDevelop.Parser
 					LoggingService.Debug("ParseInformationUpdated " + e.FileName + addition);
 				}
 				ParseInformationUpdated(null, e);
-			}).FireAndForget();
+			});
 		}
 		#endregion
 		

src/Main/SharpDevelop/Project/Build/UIBuildFeedbackSink.cs

@@ -32,9 +32,9 @@ namespace ICSharpCode.SharpDevelop.Project
 		
 		public void ReportError(BuildError error)
 		{
-			SD.MainThread.InvokeAsync(delegate {
+			SD.MainThread.InvokeAsyncAndForget(delegate {
 				TaskService.Add(new SDTask(error));
-			}).FireAndForget();
+			});
 		}
 		
 		public void ReportMessage(string message)

src/Main/SharpDevelop/Workbench/SDStatusBar.cs

@@ -77,7 +77,7 @@ namespace ICSharpCode.SharpDevelop.Workbench
 				txtStatusBarPanel.Content = message;
 			};
 			if (SD.MainThread.InvokeRequired) {
-				SD.MainThread.InvokeAsync(setMessageAction).FireAndForget();
+				SD.MainThread.InvokeAsyncAndForget(setMessageAction);
 			} else {
 				setMessageAction();
 			}

src/Main/SharpDevelop/Workbench/SingleInstanceHelper.cs

@@ -68,18 +68,17 @@ namespace ICSharpCode.SharpDevelop.Workbench
 				return new IntPtr(RESULT_PROJECT_IS_OPEN);
 			} else {
 				try {
-					SD.MainThread.InvokeAsync(
-						delegate {
-							var win32Window = PresentationSource.FromVisual(SD.Workbench.MainWindow) as System.Windows.Interop.IWin32Window;
-							if (win32Window != null)
-								NativeMethods.SetForegroundWindow(win32Window.Handle);
+					SD.MainThread.InvokeAsyncAndForget(delegate {
+						var win32Window = PresentationSource.FromVisual(SD.Workbench.MainWindow) as System.Windows.Interop.IWin32Window;
+						if (win32Window != null) {
+							NativeMethods.SetForegroundWindow(win32Window.Handle);
 						}
-					).FireAndForget();
+					});
 					string tempFileName = Path.Combine(Path.GetTempPath(), "sd" + fileNumber + ".tmp");
 					foreach (string file in File.ReadAllLines(tempFileName)) {
-						SD.MainThread.InvokeAsync(
-							delegate { SharpDevelop.FileService.OpenFile(file); }
-						).FireAndForget();
+						SD.MainThread.InvokeAsyncAndForget(delegate {
+							SharpDevelop.FileService.OpenFile(file);
+						});
 					}
 				} catch (Exception ex) {
 					LoggingService.Warn(ex);

src/Main/SharpDevelop/Workbench/WorkbenchStartup.cs

@@ -147,10 +147,10 @@ namespace ICSharpCode.SharpDevelop.Workbench
 			// a project more responsive.
 			// (and parallelism doesn't really help here; we're mostly waiting for the disk to load the code)
 			// So we do our work in the background while the user decides which project to open.
-			SD.MainThread.InvokeAsync(
+			SD.MainThread.InvokeAsyncAndForget(
 				() => new Thread(PreloadThread) { IsBackground = true, Priority = ThreadPriority.BelowNormal }.Start(),
 				DispatcherPriority.ApplicationIdle
-			).FireAndForget();
+			);
 		}
 		
 		void PreloadThread()