public void OnFrameDestroyed(IVsWindowFrame frame)
{
if (_frame.Equals(frame))
{
_threadingService.ExecuteSynchronously(_editorModel.CloseCurrentEditorAsync);
}
}
public CodeModel?GetCodeModel(Project project)
{
Requires.NotNull(project, nameof(project));
return(_threadingService.ExecuteSynchronously(() =>
{
return GetCodeModelAsync(project);
}));
}
public void Wait(string title, string message, bool allowCancel, Action <CancellationToken> action)
{
Requires.NotNull(title, nameof(title));
Requires.NotNull(message, nameof(message));
Requires.NotNull(action, nameof(action));
Instance instance = _threadingService.ExecuteSynchronously(() => WaitForLoadedAsync());
instance.Wait(title, message, allowCancel, action);
}
public void OnComplete(int hr, uint debugTargetCount, VsDebugTargetProcessInfo[] processInfoArray)
{
if (_targetsProvider is IDebugProfileLaunchTargetsProvider4 targetsProvider4)
{
_threadingService.ExecuteSynchronously(() => targetsProvider4.OnAfterLaunchAsync(_launchOptions, _activeProfile, processInfoArray));
}
else if (_targetsProvider is not null)
{
_threadingService.ExecuteSynchronously(() => _targetsProvider.OnAfterLaunchAsync(_launchOptions, _activeProfile));
}
}
private void TextDocument_FileActionOccurred(object sender, TextDocumentFileActionEventArgs args)
{
if (args.FileActionType == FileActionTypes.ContentSavedToDisk)
{
_threadingService.ExecuteSynchronously(_editorState.SaveProjectFileAsync);
}
}
public static void SetCpsProjectArguments(EnvDTE.Project project, string arguments)
{
IUnconfiguredProjectServices unconfiguredProjectServices;
IProjectServices projectServices;
if (TryGetProjectServices(project, out unconfiguredProjectServices, out projectServices))
{
var launchSettingsProvider = unconfiguredProjectServices.ExportProvider.GetExportedValue <ILaunchSettingsProvider>();
var activeLaunchProfile = launchSettingsProvider?.ActiveProfile;
if (activeLaunchProfile == null)
{
return;
}
WritableLaunchProfile writableLaunchProfile = new WritableLaunchProfile(activeLaunchProfile);
writableLaunchProfile.CommandLineArgs = arguments;
// Does not work on VS2015, which should be okay ...
// We don't hold references for VS2015, where the interface is called IThreadHandling
IProjectThreadingService projectThreadingService = projectServices.ThreadingPolicy;
projectThreadingService.ExecuteSynchronously(() =>
{
return(launchSettingsProvider.AddOrUpdateProfileAsync(writableLaunchProfile, addToFront: false));
});
}
}
public void OnComplete(int hr, uint debugTargetCount, VsDebugTargetProcessInfo[] processInfoArray)
{
if (_targetProfile != null)
{
_threadingService.ExecuteSynchronously(() => _targetProfile.OnAfterLaunchAsync(_launchOptions, _activeProfile));
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Completing the output block before the action block means any final messages that are currently being produced
// will not be sent out, which is what we want in this case.
_broadcastBlock?.Complete();
_dataSourceLink?.Dispose();
if (_actionBlock != null)
{
_actionBlock.Complete();
_threadingService.ExecuteSynchronously(async() =>
{
// Wait for any processing to finish so we don't fight over the cookies 🍪
await _actionBlock.Completion;
IVsAsyncFileChangeEx vsAsyncFileChangeEx = await _fileChangeService.GetValueAsync();
// Unsubscribe from all files
foreach (uint cookie in _fileWatcherCookies.Values)
{
await vsAsyncFileChangeEx.UnadviseFileChangeAsync(cookie);
}
});
}
}
base.Dispose(disposing);
}
/// <summary>
/// Called when one of the project files changes. In our case since only one file is watched with each cookie so the list of files
/// should be one.
/// </summary>
public int FilesChanged(uint cChanges, string[] rgpszFile, uint[] grfChange)
{
if (cChanges == 1 && (grfChange[0] & (uint)(_VSFILECHANGEFLAGS.VSFILECHG_Size | _VSFILECHANGEFLAGS.VSFILECHG_Time)) != 0)
{
IReloadableProject changedProject = null;
lock (_registeredProjects)
{
changedProject = _registeredProjects.FirstOrDefault(kv => kv.Key.ProjectFile.Equals(rgpszFile[0], StringComparison.OrdinalIgnoreCase)).Key;
}
if (changedProject != null)
{
lock (_changedProjects)
{
if (!_changedProjects.Contains(changedProject))
{
_changedProjects.Add(changedProject);
}
ReloadDelayScheduler.ScheduleAsyncTask(async(ct) =>
{
// Grab the UI thread so that we block until the reload of this set of
// projects completes.
await _threadHandling.SwitchToUIThread();
if (ct.IsCancellationRequested)
{
return;
}
// Get the list of projects and create a new empty list to put new requests
List <IReloadableProject> changedProjects;
lock (_changedProjects)
{
changedProjects = _changedProjects;
_changedProjects = new List <IReloadableProject>();
}
var failedProjects = new List <Tuple <IReloadableProject, ProjectReloadResult> >();
_threadHandling.ExecuteSynchronously(async() =>
{
foreach (var project in changedProjects)
{
ProjectReloadResult result = await project.ReloadProjectAsync().ConfigureAwait(true);
if (result == ProjectReloadResult.ReloadFailed || result == ProjectReloadResult.ReloadFailedProjectDirty)
{
failedProjects.Add(new Tuple <IReloadableProject, ProjectReloadResult>(project, result));
}
}
});
ProcessProjectReloadFailures(failedProjects);
});
}
}
}
return(VSConstants.S_OK);
}
public CodeModel GetCodeModel(Project project)
{
Requires.NotNull(project, nameof(project));
IWorkspaceProjectContext projectContext = _languageServiceHost.ActiveProjectContext;
if (projectContext == null)
{
return(null);
}
return(_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
return _codeModelFactory.GetCodeModel(projectContext, project);
}));
}
private static ProjectId?GetProjectId(IProjectThreadingService threadingService, IActiveWorkspaceProjectContextHost projectContextHost)
{
return(threadingService.ExecuteSynchronously(() =>
{
return projectContextHost.OpenContextForWriteAsync(accessor =>
{
return Task.FromResult(accessor.Context.Id);
});
}));
}
public void Add(string bstrImport)
{
if (!_importsList.IsPresent(bstrImport))
{
_threadingService.ExecuteSynchronously(async() =>
{
await _projectAccessor.OpenProjectXmlForWriteAsync(_unconfiguredProjectVSServices.Project, project =>
{
project.AddItem(ImportItemTypeName, bstrImport);
});
await _importsList.ReceiveLatestSnapshotAsync();
});
}
else
{
throw new ArgumentException(string.Format("{0} - Namespace is already imported", bstrImport), nameof(bstrImport));
}
}
public void Dispose()
{
if (_shouldClose)
{
_threadingService.ExecuteSynchronously(async() =>
{
DTE dte = await _dte.GetValueAsync();
dte.UndoContext.Close();
});
}
}
/// <summary>
/// Builds a temporary portable executable (PE) and returns its description in an XML string.
/// </summary>
public string BuildDesignTimeOutput(string bstrOutputMoniker)
{
if (DesignTimeInputsBuildManagerBridge?.AppliesTo(_unconfiguredProjectServices.Project.Capabilities) == true)
{
IDesignTimeInputsBuildManagerBridge bridge = DesignTimeInputsBuildManagerBridge.Value;
// See comment above about why we don't need any thread switching here.
return(_threadingService.ExecuteSynchronously(() => bridge.GetDesignTimeInputXmlAsync(bstrOutputMoniker)));
}
throw new NotImplementedException();
}
private int Invoke(Func <IVsENCRebuildableProjectCfg2, HResult> action)
{
return(_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
return await _projectContextHost.OpenContextForWriteAsync(accessor =>
{
return Task.FromResult(action((IVsENCRebuildableProjectCfg2)accessor.HostSpecificEditAndContinueService));
});
}));
}
public IsoPublishProvider(
IBuildSupport buildSupport,
IBuildProject buildProject,
IProjectThreadingService projectThreadingService,
IBootableProperties bootableProperties)
: base(buildSupport, buildProject)
{
_viewModel = new IsoPublishSettingsViewModel();
_viewModel.PublishPath = projectThreadingService.ExecuteSynchronously(bootableProperties.GetIsoFileFullPathAsync);
_settingsControl = new IsoPublishSettingsControl();
_settingsControl.DataContext = _viewModel;
}
private int Invoke(Func <IVsENCRebuildableProjectCfg2, HResult> action)
{
return(_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
var encProvider = (IVsENCRebuildableProjectCfg2)_host?.HostSpecificEditAndContinueService;
if (encProvider != null)
{
return action(encProvider);
}
return HResult.Unexpected;
}));
}
public void Dispose()
{
// Build manager APIs require UI thread access.
_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
if (_buildManager != null)
{
// Unregister solution build events.
_buildManager.UnadviseUpdateSolutionEvents(_solutionEventsCookie);
_buildManager = null;
}
});
}
private string GetWorkspaceContextIdFromActiveContext()
{
return(_threadingService.ExecuteSynchronously(async() =>
{
try
{
// If we're never been set an active context, we just
// pick one based on the active configuration.
return await _activeWorkspaceProjectContextHost.OpenContextForWriteAsync(a => Task.FromResult(a.ContextId));
}
catch (OperationCanceledException)
{ // Project unloading
return null;
}
}));
}
private void TextDocument_FileActionOccurred(object sender, TextDocumentFileActionEventArgs args)
{
if (args.FileActionType != FileActionTypes.ContentSavedToDisk)
{
return;
}
Assumes.Is <ITextDocument>(sender);
UIThreadHelper.VerifyOnUIThread();
var textDocument = (ITextDocument)sender;
var savedText = textDocument.TextBuffer.CurrentSnapshot.GetText();
_threadingService.ExecuteSynchronously(() => _msbuildAccessor.RunLockedAsync(true, () =>
{
_fileSystem.WriteAllText(_unconfiguredProject.FullPath, savedText);
return(Task.CompletedTask);
}));
}
/// <summary>
/// Retrieves the value or body of a macro based on the macro's name.
/// </summary>
/// <param name="bstrBuildMacroName">String containing the name of the macro.</param>
/// <param name="pbstrBuildMacroValue">String containing the value or body of the macro.</param>
/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
public int GetBuildMacroValue(string bstrBuildMacroName, out string pbstrBuildMacroValue)
{
pbstrBuildMacroValue = null;
var commonProperties = _configuredProject.Value.Services.ProjectPropertiesProvider.GetCommonProperties();
pbstrBuildMacroValue = _threadingService.ExecuteSynchronously(() => commonProperties.GetEvaluatedPropertyValueAsync(bstrBuildMacroName));
if (pbstrBuildMacroValue == null)
{
pbstrBuildMacroValue = string.Empty;
return(VSConstants.E_FAIL);
}
else
{
return(VSConstants.S_OK);
}
}
protected override void Initialize()
{
_activeConfiguredProjectProvider.Changed += OnActiveConfigurationChanged;
ConfiguredProject?configuredProject = _activeConfiguredProjectProvider.ActiveConfiguredProject;
if (configuredProject == null)
{
_threadingService.ExecuteSynchronously(async() =>
{
configuredProject = await _project.GetSuggestedConfiguredProjectAsync();
});
}
Assumes.NotNull(configuredProject);
SetValueForConfiguration(configuredProject);
}
public void Add(string bstrImport)
{
if (!_importsList.IsPresent(bstrImport))
{
_threadingService.ExecuteSynchronously(async() =>
{
using (var access = await _lockService.WriteLockAsync())
{
var project = await access.GetProjectAsync(ConfiguredProject).ConfigureAwait(true);
await access.CheckoutAsync(project.Xml.ContainingProject.FullPath).ConfigureAwait(true);
project.AddItem(importItemTypeName, bstrImport);
}
});
OnImportAdded(bstrImport);
}
else
{
throw new ArgumentException(string.Format("{0} - Namespace is already imported", bstrImport), nameof(bstrImport));
}
}
internal void ProcessDataflowChanges(IProjectVersionedValue <DesignTimeInputsDelta> obj)
{
// Cancel any in-progress queue processing
_compilationCancellationSource?.Cancel();
DesignTimeInputsDelta delta = obj.Value;
// add all of the changes to our queue
_queue.Update(delta.ChangedInputs, delta.Inputs, delta.SharedInputs, delta.TempPEOutputPath);
// Create a cancellation source so we can cancel the compilation if another message comes through
_compilationCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(_project.Services.ProjectAsynchronousTasks.UnloadCancellationToken);
JoinableTask task = _scheduler.ScheduleAsyncTask(ProcessCompileQueueAsync, _compilationCancellationSource.Token);
// For unit testing purposes, optionally block the thread until the task we scheduled is complete
if (CompileSynchronously)
{
_threadingService.ExecuteSynchronously(() => task.Task);
}
}
/// <summary>
/// Retrieves the value or body of a macro based on the macro's name.
/// </summary>
/// <param name="bstrBuildMacroName">String containing the name of the macro.</param>
/// <param name="pbstrBuildMacroValue">String containing the value or body of the macro.</param>
/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
public int GetBuildMacroValue(string bstrBuildMacroName, out string pbstrBuildMacroValue)
{
if (_configuredProject == null)
{
pbstrBuildMacroValue = null;
return(HResult.Unexpected);
}
pbstrBuildMacroValue = null;
ProjectSystem.Properties.IProjectProperties commonProperties = _configuredProject.Value.Services.ProjectPropertiesProvider.GetCommonProperties();
pbstrBuildMacroValue = _threadingService.ExecuteSynchronously(() => commonProperties.GetEvaluatedPropertyValueAsync(bstrBuildMacroName));
if (pbstrBuildMacroValue == null)
{
pbstrBuildMacroValue = string.Empty;
return(HResult.Fail);
}
else
{
return(HResult.OK);
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing && _subscription != null)
{
// Build manager APIs require UI thread access.
_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
if (_subscription != null)
{
// Unregister solution build events.
await _subscription.DisposeAsync();
}
});
}
_disposedValue = true;
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing && _buildManager != null)
{
// Build manager APIs require UI thread access.
_threadingService.ExecuteSynchronously(async() =>
{
await _threadingService.SwitchToUIThread();
if (_buildManager != null)
{
// Unregister solution build events.
_buildManager.UnadviseUpdateSolutionEvents(_solutionEventsCookie);
_buildManager = null;
}
});
}
_disposedValue = true;
}
}
private void WaitForAsync(Func <Task> asyncFunc) => _projectThreadingService.ExecuteSynchronously(asyncFunc);
private void EnsureInitialized()
{
_threadingService.ExecuteSynchronously(() => InitializeAsync(CancellationToken.None));
}
public void OnPrioritizedProjectLoadedInHost()
{
_prioritizedProjectLoadedInHost.SetResult();
_threadingService.ExecuteSynchronously(() => _prioritizedTasks.JoinTillEmptyAsync());
}