public override Task RemoveProjectAsync(ProjectId projectId, CancellationToken cancellationToken) { return(_endPoint.InvokeAsync( nameof(IDesignerAttributeListener.OnProjectRemovedAsync), new object[] { projectId }, cancellationToken)); }
public async Task <IList <PackageWithTypeResult> > FindPackagesWithTypeAsync( string source, string name, int arity, CancellationToken cancellationToken) { return(await _endPoint.InvokeAsync <IList <PackageWithTypeResult> >( nameof(IRemoteSymbolSearchUpdateEngine.FindPackagesWithTypeAsync), new object[] { source, name, arity }, cancellationToken).ConfigureAwait(false)); }
public override async Task RunRemoteAsync( string targetName, Solution?solution, IReadOnlyList <object?> arguments, CancellationToken cancellationToken ) { if (solution != null) { using var scope = await _solutionAssetStorage .StoreAssetsAsync(solution, cancellationToken) .ConfigureAwait(false); using var _ = ArrayBuilder <object?> .GetInstance( arguments.Count + 1, out var argumentsBuilder ); argumentsBuilder.Add(scope.SolutionInfo); argumentsBuilder.AddRange(arguments); await _serviceEndPoint .InvokeAsync(targetName, argumentsBuilder, cancellationToken) .ConfigureAwait(false); } else { await _serviceEndPoint .InvokeAsync(targetName, arguments, cancellationToken) .ConfigureAwait(false); } }
private async Task AnalyzeProjectAsync(Project project, Document?specificDocument, CancellationToken cancellationToken) { if (!project.SupportsCompilation) { return; } // We need to reanalyze the project whenever it (or any of its dependencies) have // changed. We need to know about dependencies since if a downstream project adds the // DesignerCategory attribute to a class, that can affect us when we examine the classes // in this project. var projectVersion = await project.GetDependentSemanticVersionAsync(cancellationToken).ConfigureAwait(false); var latestInfos = await ComputeLatestInfosAsync( project, projectVersion, specificDocument, cancellationToken).ConfigureAwait(false); // Now get all the values that actually changed and notify VS about them. We don't need // to tell it about the ones that didn't change since that will have no effect on the // user experience. // // ! is safe here as `i.changed` implies `i.info` is non-null. var changedInfos = latestInfos.Where(i => i.changed).Select(i => i.info !.Value).ToList(); if (changedInfos.Count > 0) { await _endPoint.InvokeAsync( nameof(IDesignerAttributeListener.RegisterDesignerAttributesAsync), new object[] { changedInfos }, cancellationToken).ConfigureAwait(false); } // now that we've notified VS, persist all the infos we have (changed or otherwise) back // to disk. We want to do this even when the data is unchanged so that our version // stamps will be correct for the next time we come around to analyze this project. // // Note: we have a potential race condition here. Specifically, for simplicity, the VS // side will return immediately, without actually notifying the project system. That // means that we could persist the data to local storage that isn't in sync with what // the project system knows about. i.e. if VS is closed or crashes before that // information is persisted, then these two systems will be in disagreement. this is // believed to not be a big issue given how small a time window this would be and how // easy it would be to get out of that state (just edit the file). await PersistLatestInfosAsync(project.Solution, projectVersion, latestInfos, cancellationToken).ConfigureAwait(false); }
private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e) { // workspace event is serialized events. and reset delay only get updated here if (!_resettableDelay.Task.IsCompleted) { _resettableDelay.Reset(); return; } var delay = new ResettableDelay((int)s_delay.TotalMilliseconds, expeditableDelaySource: AsynchronousOperationListenerProvider.NullListener); _resettableDelay = delay; delay.Task.ContinueWith(InvalidateAsync, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); async Task InvalidateAsync(Task _) { var document = _workspace.CurrentSolution.GetDocument(_documentId); if (document == null) { return; } var newVersion = await document.Project.GetDependentVersionAsync(CancellationToken.None).ConfigureAwait(false); if (newVersion == _lastVersion) { return; } // fire and forget. // ignore any exception such as rpc already disposed (disconnected) _lastVersion = newVersion; await _endPoint.InvokeAsync( nameof(IRemoteCodeLensDataPoint.Invalidate), Array.Empty <object>(), CancellationToken.None).ConfigureAwait(false); } }
public Task AddItemsAsync(int count) => _endPoint.InvokeAsync(nameof(AddItemsAsync), new object[] { count }, CancellationToken);
public Task OnStartedAsync() => _endPoint.InvokeAsync(nameof(SymbolFinder.FindReferencesServerCallback.OnStartedAsync), Array.Empty <object>(), _cancellationToken);
public Task ReportProgressAsync(int current, int maximum) => _endPoint.InvokeAsync(nameof(SymbolFinder.FindLiteralsServerCallback.ReportProgressAsync), new object[] { current, maximum }, _cancellationToken);
public Task OnReferenceFoundAsync(Document document, TextSpan span) => _endPoint.InvokeAsync(nameof(SymbolFinder.FindLiteralsServerCallback.OnReferenceFoundAsync), new object[] { document.Id, span }, _cancellationToken);