private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { try { // Execute analyzers in parallel. var tasks = ArrayBuilder <Task> .GetInstance(); foreach (var analyzerAndActions in _compilationEndActionsMap) { var task = Task.Run(() => { // Execute actions for a given analyzer sequentially. analyzerExecutor.ExecuteCompilationEndActions(analyzerAndActions.Value); }, cancellationToken); tasks.Add(task); } await Task.WhenAll(tasks.ToArrayAndFree()).ConfigureAwait(false); } finally { endEvent.FlushCache(); } }
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { try { await ExecuteCompilationActionsAsync(_compilationActionsMap, cancellationToken).ConfigureAwait(false); await ExecuteCompilationActionsAsync(_compilationEndActionsMap, cancellationToken).ConfigureAwait(false); } finally { endEvent.FlushCache(); } }
private async Task ProcessCompilationCompleted(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { var tasks = ArrayBuilder <Task> .GetInstance(); foreach (var da in analyzers.OfType <ICompilationEndedAnalyzer>()) { // TODO: is the overhead of creating tasks here too high compared to the cost of running them sequentially? tasks.Add(Task.Run(() => { // Catch Exception from da.OnCompilationEnded ExecuteAndCatchIfThrows(da, addDiagnostic, continueOnError, cancellationToken, () => { cancellationToken.ThrowIfCancellationRequested(); da.OnCompilationEnded(compilation, addDiagnostic, this.analyzerOptions, cancellationToken); }); })); } await Task.WhenAll(tasks.Concat(this.syntaxAnalyzers)).ConfigureAwait(false); DiagnosticQueue.Complete(); }
private void ProcessCompilationCompleted(CompilationCompletedEvent endEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken) { ExecuteCompilationActions(_compilationEndActionsMap, endEvent, analysisScope, analysisStateOpt, cancellationToken); }
private Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken) { return ExecuteCompilationActionsAsync(_compilationEndActionsMap, endEvent, analysisScope, analysisStateOpt, cancellationToken); }
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { var tasks = ArrayBuilder<Task>.GetInstance(); foreach (var da in analyzers.OfType<ICompilationAnalyzer>()) { // TODO: is the overhead of creating tasks here too high compared to the cost of running them sequentially? tasks.Add(Task.Run(() => { // Catch Exception from da.OnCompilationEnded ExecuteAndCatchIfThrows(da, addDiagnostic, continueOnAnalyzerException, cancellationToken, () => { cancellationToken.ThrowIfCancellationRequested(); da.AnalyzeCompilation(compilation, addDiagnostic, this.analyzerOptions, cancellationToken); }); })); } await Task.WhenAll(tasks.Concat(this.syntaxAnalyzers)).ConfigureAwait(false); DiagnosticQueue.Complete(); }
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { try { // Execute analyzers in parallel. var tasks = ArrayBuilder<Task>.GetInstance(); foreach (var analyzerAndActions in _compilationEndActionsMap) { var task = Task.Run(() => { // Execute actions for a given analyzer sequentially. foreach (var endAction in analyzerAndActions.Value) { Debug.Assert(endAction.Analyzer == analyzerAndActions.Key); // Catch Exception from endAction AnalyzerDriverHelper.ExecuteAndCatchIfThrows(endAction.Analyzer, _addDiagnostic, continueOnAnalyzerException, () => { cancellationToken.ThrowIfCancellationRequested(); var compilationContext = new CompilationEndAnalysisContext(_compilation, this.analyzerOptions, _addDiagnostic, cancellationToken); endAction.Action(compilationContext); }, cancellationToken); } }, cancellationToken); tasks.Add(task); } await Task.WhenAll(tasks.ToArrayAndFree()).ConfigureAwait(false); } finally { endEvent.FlushCache(); } }