/// <summary>
/// Returns an IVsTextView for the given file path, if the given file is open in Visual Studio.
/// </summary>
/// <param name="serviceProvider">The package Service Provider.</param>
/// <param name="filePath">Full Path of the file you are looking for.</param>
/// <returns>
/// The IVsTextView for this file, if it is open, null otherwise.
/// </returns>
internal static async Task <IWpfTextView> GetWpfTextViewByFilePathAsync(this Shell.IAsyncServiceProvider serviceProvider, string filePath)
{
if (filePath.IsNullOrWhiteSpace() || serviceProvider == null)
{
return(null);
}
if (!Shell.ThreadHelper.CheckAccess())
{
await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
}
DTE2 dte2 = await serviceProvider.GetServiceAsync <Shell.Interop.SDTE, DTE2>();
var oleServiceProvider = dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
if (dte2 == null || oleServiceProvider == null)
{
return(null);
}
Shell.ServiceProvider shellServiceProvider = new Shell.ServiceProvider(oleServiceProvider);
if (Shell.VsShellUtilities.IsDocumentOpen(shellServiceProvider, filePath, Guid.Empty, out var uiHierarchy, out var itemID, out var windowFrame))
{
IVsTextView textView = Shell.VsShellUtilities.GetTextView(windowFrame); // Get the IVsTextView from the windowFrame
return(await serviceProvider.GetWpfTextViewFromTextViewAsync(textView));
}
return(null);
}
public VisualStudioActiveDocumentTracker(
IThreadingContext threadingContext,
[Import(typeof(SVsServiceProvider))] IAsyncServiceProvider asyncServiceProvider,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
: base(threadingContext, assertIsForeground: false)
{
_editorAdaptersFactoryService = editorAdaptersFactoryService;
ThreadingContext.RunWithShutdownBlockAsync(async cancellationToken =>
{
await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
var monitorSelectionService = (IVsMonitorSelection)await asyncServiceProvider.GetServiceAsync(typeof(SVsShellMonitorSelection)).ConfigureAwait(true);
Assumes.Present(monitorSelectionService);
// No need to track windows if we are shutting down
cancellationToken.ThrowIfCancellationRequested();
if (ErrorHandler.Succeeded(monitorSelectionService.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_DocumentFrame, out var value)))
{
if (value is IVsWindowFrame windowFrame)
{
TrackNewActiveWindowFrame(windowFrame);
}
}
monitorSelectionService.AdviseSelectionEvents(this, out var _);
});
}
private string GetActiveFilePath(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
Task <object> t = serviceProvider.GetServiceAsync(typeof(EnvDTE.DTE));
t.Wait( );
EnvDTE80.DTE2 applicationObject = t.Result as EnvDTE80.DTE2;
foreach (EnvDTE.SelectedItem selectedItem in applicationObject.SelectedItems)
{
if (selectedItem.ProjectItem == null)
{
return(null);
}
var projectItem = selectedItem.ProjectItem;
var fullPathProperty = projectItem.Properties.Item("FullPath");
if (fullPathProperty == null)
{
return(null);
}
var fullPath = fullPathProperty.Value.ToString( );
return(fullPath);
}
return(null);
}
protected BaseCommand(IAsyncServiceProvider serviceProvider)
{
ServiceProvider = serviceProvider
?? throw new ArgumentNullException(nameof(serviceProvider));
ThreadHelper.JoinableTaskFactory.Run(SetupCommandsAsync);
}
internal VSSolutionManager(
IAsyncServiceProvider asyncServiceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
ILogger logger,
Lazy <ISettings> settings,
JoinableTaskContext joinableTaskContext)
{
Assumes.Present(asyncServiceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
Assumes.Present(joinableTaskContext);
_asyncServiceProvider = asyncServiceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
_initLock = new NuGetLockService(joinableTaskContext);
}
public static async Task <RestoreOperationProgressUI> StartAsync(
IAsyncServiceProvider asyncServiceProvider,
JoinableTaskFactory jtf,
CancellationToken token)
{
await jtf.SwitchToMainThreadAsync();
var statusBar = await asyncServiceProvider.GetServiceAsync <SVsStatusbar, IVsStatusbar>();
// Make sure the status bar is not frozen
int frozen;
statusBar.IsFrozen(out frozen);
if (frozen != 0)
{
statusBar.FreezeOutput(0);
}
statusBar.Animation(1, ref Icon);
RestoreOperationProgressUI progress = new StatusBarProgress(statusBar, jtf);
await progress.ReportProgressAsync(Resources.RestoringPackages);
return(progress);
}
OutputConsoleProvider(
Microsoft.VisualStudio.Shell.IAsyncServiceProvider asyncServiceProvider, // ambigiuous reference
IEnumerable <Lazy <IHostProvider, IHostMetadata> > hostProviders)
{
if (asyncServiceProvider == null)
{
throw new ArgumentNullException(nameof(asyncServiceProvider));
}
if (hostProviders == null)
{
throw new ArgumentNullException(nameof(hostProviders));
}
_hostProviders = hostProviders;
_vsOutputWindow = new AsyncLazy <IVsOutputWindow>(
async() =>
{
return(await asyncServiceProvider.GetServiceAsync <SVsOutputWindow, IVsOutputWindow>());
},
NuGetUIThreadHelper.JoinableTaskFactory);
_vsUIShell = new AsyncLazy <IVsUIShell>(
async() =>
{
return(await asyncServiceProvider.GetServiceAsync <SVsUIShell, IVsUIShell>());
},
NuGetUIThreadHelper.JoinableTaskFactory);
_cachedOutputConsole = new Lazy <IConsole>(
() => new OutputConsole(VsOutputWindow, VsUIShell));
}
public static async Task <IWpfTextViewHost> GetCurrentViewHostAsync(IAsyncServiceProvider serviceProvider)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var txtMgr = await serviceProvider.GetServiceAsync <SVsTextManager, IVsTextManager>();
int mustHaveFocus = 1;
if (txtMgr == null)
{
return(null);
}
txtMgr.GetActiveView(mustHaveFocus, null, out IVsTextView vTextView);
if (!(vTextView is IVsUserData userData))
{
return(null);
}
Guid guidViewHost = DefGuidList.guidIWpfTextViewHost;
userData.GetData(ref guidViewHost, out var holder);
return(holder as IWpfTextViewHost);
}
public VisualStudioActiveDocumentTracker(
IThreadingContext threadingContext,
[Import(typeof(SVsServiceProvider))] IAsyncServiceProvider asyncServiceProvider,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
: base(threadingContext, assertIsForeground: false)
{
_editorAdaptersFactoryService = editorAdaptersFactoryService;
_asyncTasks = new JoinableTaskCollection(threadingContext.JoinableTaskContext);
_asyncTasks.Add(ThreadingContext.JoinableTaskFactory.RunAsync(async() =>
{
await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
var monitorSelectionService = (IVsMonitorSelection)await asyncServiceProvider.GetServiceAsync(typeof(SVsShellMonitorSelection)).ConfigureAwait(false);
if (ErrorHandler.Succeeded(monitorSelectionService.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_DocumentFrame, out var value)))
{
if (value is IVsWindowFrame windowFrame)
{
TrackNewActiveWindowFrame(windowFrame);
}
}
monitorSelectionService.AdviseSelectionEvents(this, out var _);
}));
}
private async Task SubscribeAsync(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_serviceProvider = serviceProvider;
var commandService = await serviceProvider.GetServiceAsync <IMenuCommandService, IMenuCommandService>(throwOnFailure : false);
var menuCommandId = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(
OnRestorePackages, null, BeforeQueryStatusForPackageRestore, menuCommandId);
commandService.AddCommand(menuItem);
_vsMonitorSelection = await serviceProvider.GetServiceAsync <IVsMonitorSelection, IVsMonitorSelection>();
Assumes.Present(_vsMonitorSelection);
// get the solution not building and not debugging cookie
var guidCmdUI = VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_guid;
_vsMonitorSelection.GetCmdUIContextCookie(
ref guidCmdUI, out _solutionExistsAndFullyLoadedContextCookie);
guidCmdUI = VSConstants.UICONTEXT.SolutionExistsAndNotBuildingAndNotDebugging_guid;
_vsMonitorSelection.GetCmdUIContextCookie(
ref guidCmdUI, out _solutionNotBuildingAndNotDebuggingContextCookie);
}
public static async Task ShowExceptionAsync(IAsyncServiceProvider serviceProvider, string title, Exception ex)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
MessageBox.Show($"An error has occured during conversion: {ex}",
title, MessageBoxButton.OK, MessageBoxImage.Error);
}
public static async Task <(IWpfTextView WpfTextView, CaretPosition CaretPosition)> OpenCodeFileAndNavigateByLineAndCharAsync(
this Shell.IAsyncServiceProvider serviceProvider,
Solution solution, string filePath,
int lineNumber, int character)
{
serviceProvider.ThrowOnNull(nameof(serviceProvider));
if (lineNumber < 0)
{
throw new ArgumentOutOfRangeException(nameof(lineNumber));
}
else if (character < 0)
{
throw new ArgumentOutOfRangeException(nameof(character));
}
IWpfTextView wpfTextView = await OpenCodeWindowAsync(serviceProvider, solution, filePath);
if (wpfTextView == null)
{
var(window, textDocument) = await OpenCodeFileNotInSolutionWithDTEAsync(serviceProvider, filePath);
if (window == null)
{
return(default);
private static async Task <ITextSelection> GetSelectionInCurrentViewAsync(IAsyncServiceProvider serviceProvider,
Func <string, bool> predicate, bool mustHaveFocus)
{
var viewHost = await GetCurrentViewHostAsync(serviceProvider, predicate, mustHaveFocus);
return(viewHost?.TextView.Selection);
}
public static async Task InitializeAsync(Shell.IAsyncServiceProvider provider)
{
await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
{
s_ServerId = SERVER_PREFIX;// + System.Diagnostics.Process.GetCurrentProcess().Id.ToString();
s_PipePool = new PipePool(s_ServerId);
s_PipePool.Start();
}
{
s_Service = await provider.GetServiceAsync(typeof(SVsShellDebugger)) as IVsDebugger;
s_DTE = await provider.GetServiceAsync(typeof(SDTE)) as DTE;
}
if (s_Service != null)
{
s_Service.AdviseDebuggerEvents(Instance, out s_Cookie);
s_Service.AdviseDebugEventCallback(Instance);
}
try
{
await Task.Run(() => InitAdresses());
}
catch (Exception ex)
{
service.Output.WriteError(ex.ToString());
}
}
public InvokeTidyService(Microsoft.VisualStudio.Shell.IAsyncServiceProvider provider)
{
// constructor should only be used for simple initialization
// any usage of Visual Studio service, expensive background operations should happen in the
// asynchronous InitializeAsync method for best performance
asyncServiceProvider = provider;
}
public SolutionRestoreWorker(
IAsyncServiceProvider asyncServiceProvider,
Lazy <IVsSolutionManager> solutionManager,
Lazy <INuGetLockService> lockService,
Lazy <Common.ILogger> logger,
Lazy <INuGetErrorList> errorList,
Lazy <IOutputConsoleProvider> outputConsoleProvider)
{
if (asyncServiceProvider == null)
{
throw new ArgumentNullException(nameof(asyncServiceProvider));
}
if (solutionManager == null)
{
throw new ArgumentNullException(nameof(solutionManager));
}
if (lockService == null)
{
throw new ArgumentNullException(nameof(lockService));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (errorList == null)
{
throw new ArgumentNullException(nameof(errorList));
}
if (outputConsoleProvider == null)
{
throw new ArgumentNullException(nameof(outputConsoleProvider));
}
_asyncServiceProvider = asyncServiceProvider;
_solutionManager = solutionManager;
_lockService = lockService;
_logger = logger;
_errorList = errorList;
_outputConsoleProvider = outputConsoleProvider;
var joinableTaskContextNode = new JoinableTaskContextNode(ThreadHelper.JoinableTaskContext);
_joinableCollection = joinableTaskContextNode.CreateCollection();
JoinableTaskFactory = joinableTaskContextNode.CreateFactory(_joinableCollection);
_componentModel = new AsyncLazy <IComponentModel>(async() =>
{
return(await asyncServiceProvider.GetServiceAsync <SComponentModel, IComponentModel>());
},
JoinableTaskFactory);
_solutionLoadedEvent = new AsyncManualResetEvent();
_isCompleteEvent = new AsyncManualResetEvent();
Reset();
}
internal VSSolutionManager(
IAsyncServiceProvider asyncServiceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
ILogger logger,
Lazy <ISettings> settings,
INuGetFeatureFlagService featureFlagService,
JoinableTaskContext joinableTaskContext)
{
Assumes.Present(asyncServiceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
Assumes.Present(featureFlagService);
Assumes.Present(joinableTaskContext);
_asyncServiceProvider = asyncServiceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
_featureFlagService = featureFlagService;
_initLock = new NuGetLockService(joinableTaskContext);
_dte = new(() => asyncServiceProvider.GetDTEAsync(), NuGetUIThreadHelper.JoinableTaskFactory);
_asyncVSSolution = new(() => asyncServiceProvider.GetServiceAsync <SVsSolution, IVsSolution>(), NuGetUIThreadHelper.JoinableTaskFactory);
}
public VisualStudioDecompilerEulaService(
SVsServiceProvider serviceProvider,
IThreadingContext threadingContext
)
{
_serviceProvider = (IAsyncServiceProvider)serviceProvider;
_threadingContext = threadingContext;
}
internal DefaultVSCredentialServiceProvider(
IAsyncServiceProvider asyncServiceProvider,
Lazy <INuGetUILogger> outputConsoleLogger
)
{
_asyncServiceProvider = asyncServiceProvider ?? throw new ArgumentNullException(nameof(asyncServiceProvider));
_outputConsoleLogger = outputConsoleLogger ?? throw new ArgumentNullException(nameof(outputConsoleLogger));
}
public static IVsTextView GetTextView(this IAsyncServiceProvider serviceProvider)
{
var service = serviceProvider.GetServiceAsync(typeof(SVsTextManager)).Result;
var textManager = service as IVsTextManager2;
textManager.GetActiveView2(1, null, (uint)_VIEWFRAMETYPE.vftCodeWindow, out IVsTextView view);
return(view);
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="serviceProvider">Owner package, not null.</param>
public static async Task InitializeAsync(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
Assumes.Present(serviceProvider);
_instance = new SolutionRestoreCommand();
await _instance.SubscribeAsync(serviceProvider);
}
public RoslynVisualStudioWorkspace(
ExportProvider exportProvider,
Lazy <IStreamingFindUsagesPresenter> streamingPresenter,
[Import(typeof(SVsServiceProvider))] IAsyncServiceProvider asyncServiceProvider)
: base(exportProvider, asyncServiceProvider)
{
_streamingPresenter = streamingPresenter;
}
public NanoDeviceCommService(Microsoft.VisualStudio.Shell.IAsyncServiceProvider provider)
{
_serviceProvider = provider;
// launches the serial client and service
// create serial instance WITHOUT app associated because we don't care of app life cycle in VS extension
DebugClient = PortBase.CreateInstanceForSerial("", null);
}
public CodeConversion(IAsyncServiceProvider serviceProvider, VisualStudioWorkspace visualStudioWorkspace,
Func <Task <ConverterOptionsPage> > getOptions, VisualStudioInteraction.OutputWindow outputWindow)
{
GetOptions = getOptions;
_serviceProvider = serviceProvider;
_visualStudioWorkspace = visualStudioWorkspace;
_outputWindow = outputWindow;
}
private static async Task <Span?> FirstSelectedSpanInCurrentViewPrivateAsync(
IAsyncServiceProvider serviceProvider,
Func <string, bool> predicate, bool mustHaveFocus)
{
var selection = await GetSelectionInCurrentViewAsync(serviceProvider, predicate, mustHaveFocus);
return(selection?.SelectedSpans.First().Span);
}
public RoslynVisualStudioWorkspace(
ExportProvider exportProvider,
Lazy <IStreamingFindUsagesPresenter> streamingPresenter,
[ImportMany] IEnumerable <IDocumentOptionsProviderFactory> documentOptionsProviderFactories,
[Import(typeof(SVsServiceProvider))] IAsyncServiceProvider asyncServiceProvider)
: base(exportProvider, asyncServiceProvider, documentOptionsProviderFactories)
{
_streamingPresenter = streamingPresenter;
}
public static async Task InitializeAsync(Shell.IAsyncServiceProvider provider, string name)
{
await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_output = await provider.GetServiceAsync(typeof(SVsOutputWindow)) as IVsOutputWindow;
Assumes.Present(_output);
_name = name;
}
public VsHierarchyItemManagerProvider([Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider services, JoinableTaskContext context)
{
hierarchyManager = new JoinableLazy <IVsHierarchyItemManager>(async() =>
{
var componentModel = await services.GetServiceAsync(typeof(SComponentModel)) as IComponentModel;
return(componentModel?.GetService <IVsHierarchyItemManager>());
}, context?.Factory, executeOnMainThread: true);
}
public VisualStudioLogHubLoggerFactory(
[Import(typeof(SAsyncServiceProvider))] VSShell.IAsyncServiceProvider asyncServiceProvider,
IThreadingContext threadingContext)
{
_asyncServiceProvider = asyncServiceProvider;
_threadingContext = threadingContext;
_wasVSStartedWithLogParameterLazy = new AsyncLazy <bool>(WasVSStartedWithLogParameterAsync, _threadingContext.JoinableTaskFactory);
}
public async Task InitializeAsync(IAsyncServiceProvider asyncServiceProvider)
{
Assumes.Null(_solution);
Assumes.True(_context.IsOnMainThread, "Must be on UI thread");
_solution = await asyncServiceProvider.GetServiceAsync <IVsSolution, IVsSolution>();
Verify.HResult(_solution.AdviseSolutionEvents(this, out _cookie));
}
