private void DoTaskInternal() { if (!_taskRunning) { _taskRunning = true; Task.Factory.StartNew(() => { if (Interlocked.Read(ref _closed) == 0) { object result = null; try { result = _taskAction(); } catch (Exception ex) { Debug.Fail( String.Format("Background task exception {0}. Inner exception: {1}", ex.Message, ex.InnerException != null ? ex.InnerException.Message : "(none)") ); result = ex; } finally { UIThread.InvokeAsync(() => UIThreadCompletedCallback(result)) .HandleAllExceptions(SR.ProductName) .DoNotWait(); } } else if (Interlocked.Read(ref _closed) > 0) { UIThread.InvokeAsync((() => UIThreadCanceledCallback(null))) .HandleAllExceptions(SR.ProductName) .DoNotWait(); } }); } }
/// <summary> /// Navigates to the object that is represented by the specified route. /// </summary> /// <param name="route">The route of the object to navigate to.</param> /// <param name="data">The data to pass with the navigation request.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param> /// <returns>The <see cref="Task{TResult}"/> that represents the asynchronous operation.</returns> public async Task <bool> NavigateAsync(string route, object data, CancellationToken cancellationToken = default) { if (UIThread.CheckAccess()) { return(collection.Navigate(route, data)); } return(await UIThread.InvokeAsync(() => collection.Navigate(route, data), DispatcherPriority.Normal, cancellationToken)); }
/// <summary> /// Raises the <see cref="ICommand.CanExecuteChanged"/> event for the current <see cref="DelegateCommand{T}"/>. /// </summary> /// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param> /// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns> public async Task RaiseChangedAsync(CancellationToken cancellationToken = default) { if (UIThread.CheckAccess()) { OnCanExecuteChanged(); return; } await UIThread.InvokeAsync(OnCanExecuteChanged, DispatcherPriority.Normal, cancellationToken); }
/// <summary> /// Raises the <see cref="ICommand.CanExecuteChanged"/> event for each <see cref="IDelegateCommand"/> in the specified sequence. /// </summary> /// <param name="commands">The sequence on whose <see cref="IDelegateCommand"/> elements to raise the event.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param> /// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns> public static async Task RaiseChangedAsync(this IEnumerable <ICommand> commands, CancellationToken cancellationToken = default) { Requires.NotNull(commands, nameof(commands)); List <IDelegateCommand> list = new List <IDelegateCommand>(); list.AddRange(commands.OfType <IDelegateCommand>()); if (list.Count > 0) { await UIThread.InvokeAsync(() => RaiseChanged(list, cancellationToken), DispatcherPriority.Normal, cancellationToken); } }
internal async System.Threading.Tasks.Task ProfileProject(SessionNode session, EnvDTE.Project projectToProfile, bool openReport) { if (!await UIThread.InvokeTask(() => EnsureProjectUpToDate(projectToProfile)) && await UIThread.InvokeAsync(() => MessageBox.Show(Resources.FailedToBuild, Resources.NodejsToolsForVS, MessageBoxButton.YesNo)) == MessageBoxResult.No) { return; } var interpreterArgs = (string)projectToProfile.Properties.Item("NodeExeArguments").Value; var scriptArgs = (string)projectToProfile.Properties.Item("ScriptArguments").Value; var startBrowser = (bool)projectToProfile.Properties.Item("StartWebBrowser").Value; string launchUrl = (string)projectToProfile.Properties.Item("LaunchUrl").Value; int?port = (int?)projectToProfile.Properties.Item("NodejsPort").Value; string interpreterPath = (string)projectToProfile.Properties.Item("NodeExePath").Value; string startupFile = (string)projectToProfile.Properties.Item("StartupFile").Value; if (String.IsNullOrEmpty(startupFile)) { MessageBox.Show("Project has no configured startup file, cannot start profiling.", Resources.NodejsToolsForVS); return; } string workingDir = projectToProfile.Properties.Item("WorkingDirectory").Value as string; if (String.IsNullOrEmpty(workingDir) || workingDir == ".") { workingDir = projectToProfile.Properties.Item("ProjectHome").Value as string; if (String.IsNullOrEmpty(workingDir)) { workingDir = Path.GetDirectoryName(projectToProfile.FullName); } } RunProfiler( session, interpreterPath, interpreterArgs, startupFile, scriptArgs, workingDir, null, openReport, launchUrl, port, startBrowser ); }
private async Task RefreshAsync() { var buffers = new HashSet <ITextBuffer>(); var bufferToErrorList = new Dictionary <ITextBuffer, List <TaskProviderItem> >(); if (_errorProvider != null) { lock (_errorSources) { foreach (var kv in _errorSources) { List <TaskProviderItem> items; buffers.UnionWith(kv.Value); lock (_itemsLock) { if (!_items.TryGetValue(kv.Key, out items)) { continue; } // Don't care if functions is empty - we need to // perform the refresh to clear out old squiggles foreach (var item in items) { if (item.IsValid) { List <TaskProviderItem> itemList; if (!bufferToErrorList.TryGetValue(item.Snapshot.TextBuffer, out itemList)) { bufferToErrorList[item.Snapshot.TextBuffer] = itemList = new List <TaskProviderItem>(); } itemList.Add(item); } } } } } } await UIThread.InvokeAsync(() => { if (_errorList != null) { try { _errorList.RefreshTasks(_cookie); } catch (InvalidComObjectException) { // DevDiv2 759317 - Watson bug, COM object can go away... } } if (bufferToErrorList.Any()) { foreach (var kv in bufferToErrorList) { var tagger = _errorProvider.GetErrorTagger(kv.Key); if (tagger == null) { continue; } if (buffers.Remove(kv.Key)) { tagger.RemoveTagSpans(span => span.Span.TextBuffer == kv.Key); } foreach (var taskProviderItem in kv.Value) { taskProviderItem.CreateSquiggleSpan(tagger); } } } if (_errorProvider != null && buffers.Any()) { // Clear tags for any remaining buffers. foreach (var buffer in buffers) { var tagger = _errorProvider.GetErrorTagger(buffer); tagger.RemoveTagSpans(span => span.Span.TextBuffer == buffer); } } }); }
internal void ReloadHierarchySafe() { UIThread.InvokeAsync(ReloadHierarchy) .HandleAllExceptions(SR.ProductName) .DoNotWait(); }
private void ForceUpdateStatusBarWithNpmActivitySafe(string activity) { UIThread.InvokeAsync(() => ForceUpdateStatusBarWithNpmActivity(activity)) .HandleAllExceptions(SR.ProductName) .DoNotWait(); }
async Task Scan() { var scanId = ++_debugScanCount; ReportLine(scanId, "Started"); try { using (await _lock.LockAsync()) { _isScanQueued = false; ReportLine(scanId, "Obtained Lock\n"); var stopwatch = Stopwatch.StartNew(); var query = CreateQuery(); uint chunkIndex = 0; uint chunkSize = 50; var chunkItemsAdded = new List <MonitoredFolderItem>((int)chunkSize); var chunkItemsRemoved = new List <MonitoredFolderItem>((int)chunkSize); int addedCount = 0; int removedCount = 0; int thisIndex = -1; int existingIndex = -1; var existingItems = _cachedItems.ToList(); do { if (_cancellationToken.IsCancellationRequested) { break; } var items = await query.GetItemsAsync(chunkIndex, chunkSize); if (!items.Any()) { break; } Report("."); foreach (var item in items) { if (_cancellationToken.IsCancellationRequested) { break; } thisIndex++; var thisItem = new MonitoredFolderItem(item); existingIndex++; if (existingIndex < existingItems.Count) { var existingItem = existingItems[existingIndex]; if (existingItem.Equals(thisItem)) { continue; } var comparison = existingItem.CompareTo(thisItem); // Delete all existingItems at this index < thisItem while (comparison < 0) { existingItems.RemoveAt(existingIndex); chunkItemsRemoved.Add(existingItem); if (existingItems.Count == existingIndex) { break; } existingItem = existingItems[existingIndex]; comparison = existingItem.CompareTo(thisItem); } if (existingIndex == existingItems.Count) { existingItems.Add(thisItem); chunkItemsAdded.Add(thisItem); } else if (comparison > 0) { existingItems.Insert(existingIndex, thisItem); chunkItemsAdded.Add(thisItem); } } else { existingItems.Add(thisItem); chunkItemsAdded.Add(thisItem); } } if (_cancellationToken.IsCancellationRequested) { break; } // Raise event if (chunkItemsAdded.Any() || chunkItemsRemoved.Any()) { await UIThread.InvokeAsync(() => { Changed?.Invoke(this, new MonitoredFolderChangedArgs(chunkItemsAdded, chunkItemsRemoved)); }); addedCount += chunkItemsAdded.Count; removedCount += chunkItemsRemoved.Count; chunkItemsAdded.Clear(); chunkItemsRemoved.Clear(); } // Move Next chunkIndex += (uint)items.Count(); }while (true); // Any remaining existingItems are removed if (existingIndex < existingItems.Count - 1) { var itemsToRemove = existingItems.Where((_, i) => i > existingIndex).ToList(); chunkItemsRemoved.Clear(); chunkItemsRemoved.AddRange(itemsToRemove); removedCount += itemsToRemove.Count; var numberToRemove = existingItems.Count - 1 - existingIndex; existingItems.RemoveRange(existingItems.Count - numberToRemove, numberToRemove); await UIThread.InvokeAsync(() => { Changed?.Invoke(this, new MonitoredFolderChangedArgs(null, chunkItemsRemoved)); }); } // Result _cachedItems = existingItems; stopwatch.Stop(); if (chunkIndex > 0) { ReportLine($"+{addedCount} -{removedCount}"); } ReportLine(scanId, $"Finished. Processed {chunkIndex} items in {stopwatch.ElapsedMilliseconds} ms."); ReportLine("Releasing Lock"); } } catch (Exception ex) { ReportLine(scanId, $"Exception\n{ex}"); } }