public StartupProjectRegistrar(
UnconfiguredProject project,
IAsyncServiceProvider serviceProvider,
IProjectThreadingService threadingService,
ISafeProjectGuidService projectGuidService,
IActiveConfiguredProjectSubscriptionService projectSubscriptionService,
ActiveConfiguredProject <DebuggerLaunchProviders> launchProviders)
: base(threadingService.JoinableTaskContext)
{
_serviceProvider = serviceProvider;
_threadingService = threadingService;
_projectGuidService = projectGuidService;
_projectSubscriptionService = projectSubscriptionService;
_launchProviders = launchProviders;
}
public static async Task <VirtualMemoryNotificationListener> CreateAsync(
VisualStudioWorkspace workspace,
IThreadingContext threadingContext,
IAsyncServiceProvider serviceProvider,
IGlobalOptionService globalOptions,
CancellationToken cancellationToken)
{
await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
var shell = (IVsShell?)await serviceProvider.GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
Assumes.Present(shell);
return(new VirtualMemoryNotificationListener(threadingContext, shell, globalOptions, workspace));
}
public static async Task <TInterface> GetServiceAsync <TService, TInterface>(
this Microsoft.VisualStudio.Shell.IAsyncServiceProvider site)
where TInterface : class
{
var service = await site.GetServiceAsync(typeof(TService));
if (service != null)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
return(service as TInterface);
}
return(null);
}
public VsService([Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider serviceProvider, JoinableTaskContext joinableTaskContext)
{
Requires.NotNull(serviceProvider, nameof(serviceProvider));
Requires.NotNull(joinableTaskContext, nameof(joinableTaskContext));
_value = new AsyncLazy <T>(async() =>
{
// If the service request requires a package load, GetServiceAsync will
// happily do that on a background thread.
object iunknown = await serviceProvider.GetServiceAsync(ServiceType);
// We explicitly switch to the UI thread to avoid doing a QueryInterface
// via blocking RPC for STA objects when we cast explicitly to the type
await joinableTaskContext.Factory.SwitchToMainThreadAsync();
return((T)iunknown);
}, joinableTaskContext.Factory);
}
public ChannelOutputConsole(IAsyncServiceProvider asyncServiceProvider, Guid channelId, string outputName, JoinableTaskFactory joinableTaskFactory)
{
if (asyncServiceProvider == null)
{
throw new ArgumentNullException(nameof(asyncServiceProvider));
}
_channelGuid = channelId;
_channelId = _channelGuid.ToString();
_channelOutputName = outputName ?? throw new ArgumentNullException(nameof(outputName));
_joinableTaskFactory = joinableTaskFactory ?? throw new ArgumentNullException(nameof(joinableTaskFactory));
_serviceBrokerClient = new AsyncLazy <ServiceBrokerClient>(async() =>
{
IBrokeredServiceContainer container = (IBrokeredServiceContainer)await asyncServiceProvider.GetServiceAsync(typeof(SVsBrokeredServiceContainer));
Assumes.Present(container);
IServiceBroker serviceBroker = container.GetFullAccessServiceBroker();
return(new ServiceBrokerClient(serviceBroker, _joinableTaskFactory));
}, _joinableTaskFactory);
}
private StartupProjectRegistrar CreateInstance(
IAsyncServiceProvider serviceProvider = null,
IVsStartupProjectsListService vsStartupProjectsListService = null,
IProjectThreadingService threadingService = null,
IProjectGuidService2 projectGuidService = null,
IActiveConfiguredProjectSubscriptionService projectSubscriptionService = null,
ActiveConfiguredProject <DebuggerLaunchProviders> launchProviders = null)
{
if (serviceProvider == null)
{
var sp = new IAsyncServiceProviderMoq();
sp.AddService(typeof(SVsStartupProjectsListService), vsStartupProjectsListService ?? IVsStartupProjectsListServiceFactory.Create());
serviceProvider = sp;
}
return(new StartupProjectRegistrar(
serviceProvider,
threadingService ?? new IProjectThreadingServiceMock(),
projectGuidService ?? IProjectGuidService2Factory.ImplementGetProjectGuidAsync(Guid.NewGuid()),
projectSubscriptionService ?? IActiveConfiguredProjectSubscriptionServiceFactory.Create(),
launchProviders));
}
public static Task <IComponentModel> GetComponentModelAsync(
this Microsoft.VisualStudio.Shell.IAsyncServiceProvider site)
{
return(site.GetServiceAsync <SComponentModel, IComponentModel>());
}
public static Task <EnvDTE.DTE> GetDTEAsync(
this Microsoft.VisualStudio.Shell.IAsyncServiceProvider site)
{
return(site.GetServiceAsync <SDTE, EnvDTE.DTE>());
}
private static async System.Threading.Tasks.Task <T> GetMefServiceIteratorAsync <T>(this Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
where T : class
{
IComponentModel componentModel = await serviceProvider.GetServiceAsync(typeof(SComponentModel)) as IComponentModel;
return(GetMefService <T>(componentModel));
}
private VsService <TService, TInterface> CreateInstance <TService, TInterface>(IAsyncServiceProvider serviceProvider = null, IProjectThreadingService threadingService = null)
{
serviceProvider = serviceProvider ?? IAsyncServiceProviderFactory.Create();
threadingService = threadingService ?? IProjectThreadingServiceFactory.Create();
return(new VsService <TService, TInterface>(serviceProvider, threadingService.JoinableTaskContext.Context));
}
public VsService([Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider serviceProvider, IProjectThreadingService threadingService)
: base(serviceProvider, threadingService)
{
}
public SolutionMonitor(ApprenticePackage package)
{
this.package = Requires.NotNull(package, nameof(package));
this.asp = Requires.NotNull((IAsyncServiceProvider)package, nameof(package));
}
public static async System.Threading.Tasks.Task <TextViewSelection> GetSelectionAsync(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
var service = serviceProvider.GetServiceAsync(typeof(SVsTextManager));
var textManager = await Task.Run(() => service) as IVsTextManager2;
IVsTextView view;
int result = textManager.GetActiveView2(1, null, (uint)_VIEWFRAMETYPE.vftCodeWindow, out view);
view.GetSelection(out int startLine, out int startColumn, out int endLine, out int endColumn);//end could be before beginning
var start = new TextViewPosition(startLine, startColumn);
var end = new TextViewPosition(endLine, endColumn);
view.GetSelectedText(out string selectedText);
TextViewSelection selection = new TextViewSelection(start, end, selectedText);
return(selection);
}
public static async System.Threading.Tasks.Task <string> GetActiveDocumentFilePathAsync(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
var service = serviceProvider.GetServiceAsync(typeof(DTE));
EnvDTE80.DTE2 applicationObject = await Task.Run(() => service) as EnvDTE80.DTE2;
await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
return(applicationObject.ActiveDocument.FullName);
}
public static async Task <TInterface> GetServiceAsync <TService, TInterface>(
this Microsoft.VisualStudio.Shell.IAsyncServiceProvider site)
where TInterface : class
{
return(await site.GetServiceAsync(typeof(TService)) as TInterface);
}
public GenContextBootstrapService(Microsoft.VisualStudio.Shell.IAsyncServiceProvider provider)
{
serviceProvider = provider;
}
public PackageManagerUICommandHandler(JoinableTaskFactory joinableTaskFactory, IAsyncServiceProvider asyncServiceProvider)
{
_joinableTaskFactory = joinableTaskFactory ?? throw new ArgumentNullException(nameof(joinableTaskFactory));
_asyncServiceProvider = asyncServiceProvider ?? throw new ArgumentNullException(nameof(asyncServiceProvider));
}
public async Task InitializeAsync(Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
{
Host = await serviceProvider.GetServiceAsync(typeof(SDTE)) as DTE;
}
private static async System.Threading.Tasks.Task <T> GetMefServiceAsyncIterator <T>(this Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
where T : class
{
IComponentModel componentModel = await serviceProvider.GetServiceAsync(typeof(SComponentModel)) as IComponentModel;
// We don't want to throw in the case of a missing service (don't use GetService<T>)
return(componentModel?.GetExtensions <T>().SingleOrDefault());
}
