private ILookup<string, FileSystemPath> installedPackages; // there can be several versions of one package (different versions)
#endregion Fields
#region Constructors
public NuGetApi(ISolution solution, Lifetime lifetime, IComponentModel componentModel, IThreading threading, ProjectModelSynchronizer projectModelSynchronizer)
{
this.solution = solution;
this.threading = threading;
this.projectModelSynchronizer = projectModelSynchronizer;
try
{
vsPackageInstallerServices = componentModel.GetExtensions<IVsPackageInstallerServices>().SingleOrDefault();
vsPackageInstaller = componentModel.GetExtensions<IVsPackageInstaller>().SingleOrDefault();
vsPackageInstallerEvents = componentModel.GetExtensions<IVsPackageInstallerEvents>().SingleOrDefault();
}
catch (Exception e)
{
Logger.LogException("Unable to get NuGet interfaces.", e);
}
if (!IsNuGetAvailable)
{
Logger.LogMessage(LoggingLevel.VERBOSE, "[NUGET PLUGIN] Unable to get NuGet interfaces. No exception thrown");
return;
}
lifetime.AddBracket(
() => vsPackageInstallerEvents.PackageInstalled += RecalcInstalledPackages,
() => vsPackageInstallerEvents.PackageInstalled -= RecalcInstalledPackages);
lifetime.AddBracket(
() => vsPackageInstallerEvents.PackageUninstalled += RecalcInstalledPackages,
() => vsPackageInstallerEvents.PackageUninstalled -= RecalcInstalledPackages);
RecalcInstalledPackages(null);
}
public void Execute <TCommand>(TCommand command) where TCommand : ICommand
{
var handler = components.GetExtensions <ICommandHandler <TCommand> >().FirstOrDefault();
if (handler == null)
{
throw new NotSupportedException(Strings.CommandBus.NoHandler(command.GetType()));
}
handler.Execute(command);
}
public NuGetApi(IComponentModel componentModel, IThreading threading)
{
this.threading = threading;
try
{
vsPackageInstallerServices = componentModel.GetExtensions <IVsPackageInstallerServices>().SingleOrDefault();
vsPackageInstaller = componentModel.GetExtensions <IVsPackageInstaller>().SingleOrDefault();
}
catch (Exception e)
{
Logger.LogException("Unable to get NuGet interfaces.", e);
}
}
public IFileSystem GetFileSystem(string path)
{
// Get the source control providers
var providers = _componentModel.GetExtensions <ISourceControlFileSystemProvider>();
// Get the repository path
IFileSystem fileSystem = null;
var sourceControl = (SourceControl2)_dte.SourceControl;
if (providers.Any() && sourceControl != null)
{
SourceControlBindings binding = null;
try {
// Get the binding for this solution
binding = sourceControl.GetBindings(_dte.Solution.FullName);
}
catch (NotImplementedException) {
// Some source control providers don't bother to implement this.
// TFS might be the only one using it
}
if (binding != null)
{
fileSystem = providers.Select(provider => GetFileSystemFromProvider(provider, path, binding))
.Where(fs => fs != null)
.FirstOrDefault();
}
}
return(fileSystem ?? new PhysicalFileSystem(path));
}
public static T GetMefService <T>(this IComponentModel componentModel)
where T : class
{
// We don't want to throw in the case of a missing service (don't use GetService<T>)
var results = componentModel?.GetExtensions <T>().ToList();
if (results == null)
{
return(null);
}
else if (results.Count == 0)
{
Debug.Fail($"Cannot find any export of {typeof(T)}");
return(null);
}
else if (results.Count > 1)
{
Debug.Fail($"Not expecting to find multiple export of {typeof(T)}");
return(null);
}
else
{
return(results[0]);
}
}
protected override void Initialize()
{
base.Initialize();
// Load the Roslyn package so that its FatalError handlers are hooked up.
IVsPackage setupPackage;
var shell = (IVsShell)this.GetService(typeof(SVsShell));
shell.LoadPackage(Guids.RoslynPackageId, out setupPackage);
shell.LoadPackage(Microsoft.VisualStudio.InteractiveWindow.Shell.Guids.InteractiveWindowPackageId, out setupPackage);
_componentModel = (IComponentModel)GetService(typeof(SComponentModel));
_interactiveWindowProvider = _componentModel.DefaultExportProvider.GetExportedValue <TVsInteractiveWindowProvider>();
var menuCommandService = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
InitializeMenuCommands(menuCommandService);
InitializeResetInteractiveFromProjectCommand(menuCommandService);
var telemetrySetupExtensions = _componentModel.GetExtensions <IRoslynTelemetrySetup>();
foreach (var telemetrySetup in telemetrySetupExtensions)
{
telemetrySetup.Initialize(this);
}
}
static async Task <ImmutableArray <IOptionPersisterProvider> > GetOptionPersistersAsync(IComponentModel componentModel, CancellationToken cancellationToken)
{
// Switch to a background thread to ensure assembly loads don't show up as UI delays attributed to
// InitializeAsync.
await TaskScheduler.Default;
return(componentModel.GetExtensions <IOptionPersisterProvider>().ToImmutableArray());
}
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());
}
public static IVsPackageInstaller LoadService(IServiceProvider serviceProvider)
{
IComponentModel componentModel = serviceProvider.GetService(typeof(SComponentModel)) as IComponentModel;
var installer = componentModel.GetExtensions <IVsPackageInstaller>().SingleOrDefault();
Debug.Assert(installer != null, "Cannot find IVsPackageInstaller");
return(installer);
}
public static ITelemetryLogger GetLogger(IComponentModel componentModel)
{
if (componentModel != null)
{
return(componentModel.GetExtensions <ITelemetryLogger>().SingleOrDefault());
}
return(null);
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
IComponentModel componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel));
// Load and initialize all commands.
componentModel.GetExtensions <ICommandBase>();
}
internal static IEnumerable <T> GetMefExtensions <T>() where T : class
{
IComponentModel componentModel = Common.GetComponentModel(Common.GlobalServiceProvider);
if (componentModel != null)
{
return(componentModel.GetExtensions <T>());
}
return(null);
}
internal static IPythonInterpreterFactory[] GetAllPythonInterpreterFactories(this IComponentModel model)
{
var interpreters = new List <IPythonInterpreterFactory>();
foreach (var provider in model.GetExtensions <IPythonInterpreterFactoryProvider>())
{
interpreters.AddRange(provider.GetInterpreterFactories());
}
interpreters.Sort((x, y) => x.GetInterpreterDisplay().CompareTo(y.GetInterpreterDisplay()));
return(interpreters.ToArray());
}
public static ITelemetryLogger GetLogger(IServiceProvider serviceProvider)
{
IComponentModel componentModel = serviceProvider.GetService(typeof(SComponentModel)) as IComponentModel;
if (componentModel != null)
{
return(componentModel.GetExtensions <ITelemetryLogger>().SingleOrDefault());
}
return(null);
}
private static IReplEvaluator GetReplEvaluator(IComponentModel model, string replId, out string[] roles) {
roles = new string[0];
foreach (var provider in model.GetExtensions<IReplEvaluatorProvider>()) {
var evaluator = provider.GetEvaluator(replId);
if (evaluator != null) {
roles = evaluator.GetType().GetCustomAttributes(typeof(ReplRoleAttribute), true).Select(r => ((ReplRoleAttribute)r).Name).ToArray();
return evaluator;
}
}
return null;
}
protected override IEnumerable <IObservable <TEvent> > GetObservables <TEvent>()
{
// Since each IObservable component is exported explicitly for each of
// the base classes of the generated event, there will be, for example:
// for IObservable<ProjectAdded>, an export for that interface, as well as
// a (say) IObservable<ProjectEvent> and IObservable<BaseEvent>, so that
// when someone subscribes to stream.Of<BaseEvent>, we just need to retrieve
// the concrete IObservable<BaseEvent> here, which considerably simplifies
// the implementation here and avoids caching/invalidation/traversal of
// TEvent hierarchy, etc.
return(components.GetExtensions <IObservable <TEvent> >());
}
public static T GetMefService <T>(this IServiceProvider serviceProvider)
where T : class
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
IComponentModel componentModel = serviceProvider.GetService <SComponentModel, IComponentModel>();
// We don't want to throw in the case of a missing service (don't use GetService<T>)
return(componentModel?.GetExtensions <T>().SingleOrDefault());
}
public static async System.Threading.Tasks.Task <T> GetMefServiceAsync <T>(this Microsoft.VisualStudio.Shell.IAsyncServiceProvider serviceProvider)
where T : class
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
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());
}
private static IReplEvaluator GetReplEvaluator(IComponentModel model, string replId)
{
foreach (var provider in model.GetExtensions <IReplEvaluatorProvider>())
{
var evaluator = provider.GetEvaluator(replId);
if (evaluator != null)
{
return(evaluator);
}
}
return(null);
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
IComponentModel componentModel = await this.GetServiceAsync <SComponentModel, IComponentModel>();
IEnumerable <IPackageService> packageServices = componentModel.GetExtensions <IPackageService>();
await JoinableTaskFactory.SwitchToMainThreadAsync();
foreach (IPackageService packageService in packageServices)
{
await packageService.InitializeAsync(this);
}
}
private static IReplEvaluator GetReplEvaluator(IComponentModel model, string replId, out string[] roles)
{
roles = new string[0];
foreach (var provider in model.GetExtensions <IReplEvaluatorProvider>())
{
var evaluator = provider.GetEvaluator(replId);
if (evaluator != null)
{
roles = evaluator.GetType().GetCustomAttributes(typeof(ReplRoleAttribute), true).Select(r => ((ReplRoleAttribute)r).Name).ToArray();
return(evaluator);
}
}
return(null);
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
IComponentModel componentModel = await this.GetServiceAsync <SComponentModel, IComponentModel>();
IEnumerable <IPackageService> packageServices = componentModel.GetExtensions <IPackageService>();
#pragma warning disable RS0030 // Do not used banned APIs
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
#pragma warning restore RS0030 // Do not used banned APIs
foreach (IPackageService packageService in packageServices)
{
await packageService.InitializeAsync(this);
}
}
private async Task LoadOptionPersistersAsync(IComponentModel componentModel, CancellationToken cancellationToken)
{
var listenerProvider = componentModel.GetService <IAsynchronousOperationListenerProvider>();
using var token = listenerProvider.GetListener(FeatureAttribute.Workspace).BeginAsyncOperation(nameof(LoadOptionPersistersAsync));
// Switch to a background thread to ensure assembly loads don't show up as UI delays attributed to
// InitializeAsync.
await TaskScheduler.Default;
var persisterProviders = componentModel.GetExtensions <IOptionPersisterProvider>().ToImmutableArray();
foreach (var provider in persisterProviders)
{
_ = await provider.GetOrCreatePersisterAsync(cancellationToken).ConfigureAwait(true);
}
}
public SourceControlManager GetSourceControlManager()
{
return(ThreadHelper.JoinableTaskFactory.Run(async delegate
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (_dte != null &&
_dte.SourceControl != null)
{
var sourceControl = (SourceControl2)_dte.SourceControl;
if (sourceControl != null)
{
SourceControlBindings sourceControlBinding = null;
try
{
// Get the binding for this solution
sourceControlBinding = sourceControl.GetBindings(_dte.Solution.FullName);
}
catch (NotImplementedException)
{
// Some source control providers don't bother to implement this.
// TFS might be the only one using it
}
if (sourceControlBinding == null ||
String.IsNullOrEmpty(sourceControlBinding.ProviderName)
||
!sourceControlBinding.ProviderName.Equals(TfsProviderName, StringComparison.OrdinalIgnoreCase))
{
// Return null, if the Source control provider is not TFS
return null;
}
var tfsProviders = _componentModel.GetExtensions <ITFSSourceControlManagerProvider>();
if (tfsProviders != null &&
tfsProviders.Any())
{
return tfsProviders.Select(provider => provider.GetTFSSourceControlManager(sourceControlBinding))
.FirstOrDefault(tp => tp != null);
}
}
}
return null;
}));
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
_componentModel = (IComponentModel) await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
cancellationToken.ThrowIfCancellationRequested();
Assumes.Present(_componentModel);
FatalError.Handler = FailFast.OnFatalException;
FatalError.NonFatalHandler = WatsonReporter.Report;
// We also must set the FailFast handler for the compiler layer as well
var compilerAssembly = typeof(Compilation).Assembly;
var compilerFatalError = compilerAssembly.GetType("Microsoft.CodeAnalysis.FatalError", throwOnError: true);
var property = compilerFatalError.GetProperty(nameof(FatalError.Handler), BindingFlags.Static | BindingFlags.Public);
var compilerFailFast = compilerAssembly.GetType(typeof(FailFast).FullName, throwOnError: true);
var method = compilerFailFast.GetMethod(nameof(FailFast.OnFatalException), BindingFlags.Static | BindingFlags.NonPublic);
property.SetValue(null, Delegate.CreateDelegate(property.PropertyType, method));
_workspace = _componentModel.GetService <VisualStudioWorkspace>();
_workspace.Services.GetService <IExperimentationService>();
// Ensure the options persisters are loaded since we have to fetch options from the shell
_componentModel.GetExtensions <IOptionPersister>();
RoslynTelemetrySetup.Initialize(this);
// set workspace output pane
_outputPane = new WorkspaceFailureOutputPane(_componentModel.GetService <IThreadingContext>(), this, _workspace);
InitializeColors();
// load some services that have to be loaded in UI thread
LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(cancellationToken).Forget();
_solutionEventMonitor = new SolutionEventMonitor(_workspace);
TrackBulkFileOperations();
RegisterCodeCleanupProvider();
}
protected override void Initialize()
{
base.Initialize();
_componentModel = (IComponentModel)GetService(typeof(SComponentModel));
_interactiveWindowProvider = _componentModel.DefaultExportProvider.GetExportedValue <TVsInteractiveWindowProvider>();
var menuCommandService = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
InitializeMenuCommands(menuCommandService);
InitializeResetInteractiveFromProjectCommand(menuCommandService);
var telemetrySetupExtensions = _componentModel.GetExtensions <IRoslynTelemetrySetup>();
foreach (var telemetrySetup in telemetrySetupExtensions)
{
telemetrySetup.Initialize(this);
}
}
/// <summary>
/// Should be done on demand rather than during init
/// </summary>
private void GetOutputParsers()
{
IComponentModel componentModel = this.GetService <SComponentModel, IComponentModel>();
foreach (IOutputParserProvider provider in componentModel.GetExtensions <IOutputParserProvider>())
{
try
{
IOutputParser outputParser = provider.GetOutputParser();
if (outputParser != null)
{
this.outputParsers.Add(outputParser);
}
}
catch (Exception ex)
{
this.package.Telemetry.TrackException(ex);
}
}
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
_componentModel = (IComponentModel) await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
cancellationToken.ThrowIfCancellationRequested();
Assumes.Present(_componentModel);
// Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
// the background thread then we will experience hangs like we see in this bug:
// https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
// https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
var telemetrySession = TelemetryService.DefaultSession;
WatsonReporter.InitializeFatalErrorHandlers(telemetrySession);
// Ensure the options persisters are loaded since we have to fetch options from the shell
_componentModel.GetExtensions <IOptionPersister>();
_workspace = _componentModel.GetService <VisualStudioWorkspace>();
_workspace.Services.GetService <IExperimentationService>();
RoslynTelemetrySetup.Initialize(this, telemetrySession);
InitializeColors();
// load some services that have to be loaded in UI thread
LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(cancellationToken).Forget();
_solutionEventMonitor = new SolutionEventMonitor(_workspace);
TrackBulkFileOperations();
}
