private ExtensionInstalledChecker(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
public VSIXPackageInformation GetCurrentVSIXPackageInformation()
{
VSIXPackageInformation outInfo = null;
try
{
outInfo = new VSIXPackageInformation();
// get ExtensionManager
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
// get your extension by Product Id
IInstalledExtension myExtension = manager.GetInstalledExtension("FASTBuildMonitorVSIX.44bf85a5-7635-4a2e-86d7-7b7f3bf757a8");
// get current version
outInfo._version = myExtension.Header.Version;
outInfo._authors = myExtension.Header.Author;
outInfo._packageName = myExtension.Header.Name;
outInfo._moreInfoURL = myExtension.Header.MoreInfoUrl.OriginalString;
}
catch (System.Exception ex)
{
Console.WriteLine("Exception: " + ex.ToString());
}
return(outInfo);
}
public void Uninstall(string id, bool removeDependencies, IEnumerable <string> dependencies, Action <LoggingLevel, string> logger)
{
if (id != ExtensionId)
{
return;
}
IVsExtensionManager vsExtensionManager = _vsExtensionManager.CanBeNull;
if (vsExtensionManager == null)
{
return;
}
IInstalledExtension thisExtension;
if (!vsExtensionManager.TryGetInstalledExtension(VsIntegrationExtensionId, out thisExtension))
{
return;
}
try {
vsExtensionManager.Uninstall(thisExtension);
}
catch (Exception ex) {
logger(LoggingLevel.WARN, "Could not uninstall EnhancedTooltip VS integration: {0}".FormatEx(ex));
}
}
public ITagger <T> CreateTagger <T>(ITextView textView, ITextBuffer buffer) where T : ITag
{
if (s_underlineClassification == null)
{
s_underlineClassification = ClassificationRegistry.GetClassificationType("UnderlineClassificationProPack");
}
if (textView.TextBuffer != buffer)
{
return(null);
}
IVsExtensionManager manager = _serviceProvider.GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (manager == null)
{
return(null);
}
IInstalledExtension extension;
manager.TryGetInstalledExtension("GoToDef", out extension);
if (extension != null)
{
return(null);
}
return(GetClassifierForView(textView) as ITagger <T>);
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
_outputPane = outputPane;
}
public bool Uninstall(string id, bool skipGlobal)
{
if (!extensionManager.TryGetInstalledExtension(id, out var _))
{
return(false);
}
while (extensionManager.TryGetInstalledExtension(id, out var installedExtension))
{
if (skipGlobal && installedExtension.InstalledPerMachine)
{
return(false);
}
Console.WriteLine($"Uninstalling {NameVer(installedExtension)}");
extensionManager.Uninstall(installedExtension);
DirectoryUtil.DeleteHard(installedExtension.InstallPath, true);
ExtensionManagerUtil.RemovePendingExtensionDeletion(externalSettingsManager, installedExtension.Header);
// Reset extension manager cache
ExtensionManagerService.Dispose();
extensionManager = ExtensionManagerService.Create(externalSettingsManager);
}
return(true);
}
public static async Task RunAsync()
{
bool hasUpdates = await Installer.CheckForUpdatesAsync();
if (!hasUpdates)
{
return;
}
_hasShownProgress = false;
// Waits for MEF to initialize before the extension manager is ready to use
await _package.GetServiceAsync(typeof(SComponentModel));
IVsExtensionRepository repository = await _package.GetServiceAsync(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IVsExtensionManager manager = await _package.GetServiceAsync(typeof(SVsExtensionManager)) as IVsExtensionManager;
Version vsVersion = VsHelpers.GetVisualStudioVersion();
_handler = await SetupTaskStatusCenter();
Task task = Installer.RunAsync(vsVersion, repository, manager, _handler.UserCancellation);
_handler.RegisterTask(task);
}
private IEnumerable <ExtensionEntry> GetMissingExtensions(IVsExtensionManager manager)
{
IEnumerable <IInstalledExtension> installed = manager.GetInstalledExtensions();
IEnumerable <ExtensionEntry> notInstalled = LiveFeed.Extensions.Where(ext => !installed.Any(ins => ins.Header.Identifier == ext.Id));
return(notInstalled.Where(ext => !Store.HasBeenInstalled(ext.Id)));
}
public static string GetContentLocation(string contentName)
{
IVsExtensionManager extensionManagerService = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (extensionManagerService == null)
{
Logging.Log(Logging.Severity.Error, "Unable to obtain extension manager service");
return(null);
}
IInstalledExtension lufaExt = null;
if (extensionManagerService.TryGetInstalledExtension(GuidList.guidLUFAVSIXManifestString, out lufaExt) == false)
{
Logging.Log(Logging.Severity.Error, "Unable to obtain LUFA extension information");
return(null);
}
string contentPath = null;
try
{
string contentRelativePath = lufaExt.Content.Where(c => c.ContentTypeName == contentName).First().RelativePath;
contentPath = Path.Combine(lufaExt.InstallPath, contentRelativePath);
}
catch (Exception e)
{
Logging.Log(Logging.Severity.Error, "Could not get content location: {0}", e.Message);
}
return(contentPath);
}
internal CommandRunner(string appPath, Version version, string rootSuffix, IVsExtensionManager extensionManager)
{
_appPath = appPath;
_version = version;
_rootSuffix = rootSuffix;
_extensionManager = extensionManager;
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair <string, string> product)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
try
{
GalleryEntry entry = repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
Telemetry.TrackEvent(installable.Header.Name);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public static string GetVersion(out ReleaseTypes versionType)
{
versionType = ReleaseTypes.Unknown;
IVsExtensionManager extensionManagerService = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (extensionManagerService == null)
{
return(null);
}
IInstalledExtension lufaExt = null;
if (extensionManagerService.TryGetInstalledExtension(GuidList.guidLUFAVSIXManifestString, out lufaExt) == false)
{
return(null);
}
string[] lufaVersionSegments = lufaExt.Header.Version.ToString().Split('.');
if (lufaVersionSegments.First().Equals("0"))
{
versionType = ReleaseTypes.Test;
return(lufaVersionSegments[1]);
}
else
{
versionType = ReleaseTypes.Normal;
return(lufaVersionSegments.Last());
}
}
public IMouseProcessor GetAssociatedProcessor(IWpfTextView view)
{
var buffer = view.TextBuffer;
IOleCommandTarget shellCommandDispatcher = GetShellCommandDispatcher(view);
if (shellCommandDispatcher == null)
{
return(null);
}
ITelemetrySession telemetrySession = TelemetrySessionForPPT.Create(typeof(GoToDefMouseHandler).Assembly);
IVsExtensionManager manager = _globalServiceProvider.GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (manager == null)
{
return(null);
}
IInstalledExtension extension;
manager.TryGetInstalledExtension("GoToDef", out extension);
if (extension != null)
{
return(null);
}
return(new GoToDefMouseHandler(view,
shellCommandDispatcher,
telemetrySession,
_aggregatorFactory.GetClassifier(buffer),
_navigatorService.GetTextStructureNavigator(buffer),
CtrlKeyState.GetStateForView(view)));
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair<string, string> product, DataStore store)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
try
{
GalleryEntry entry = repository.CreateQuery<GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
store.PreviouslyInstalledExtensions.Add(entry.VsixID);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
_outputPane = outputPane;
}
private async Task InstallAsync(IEnumerable <ExtensionEntry> extensions,
IVsExtensionRepository repository,
IVsExtensionManager manager,
CancellationToken token)
{
if (!extensions.Any() || token.IsCancellationRequested)
{
return;
}
await Task.Run(() =>
{
try
{
foreach (ExtensionEntry extension in extensions)
{
if (token.IsCancellationRequested)
{
return;
}
InstallExtension(extension, repository, manager);
}
}
catch (Exception ex)
{
Debug.Write(ex);
}
finally
{
Store.Save();
}
}).ConfigureAwait(false);
}
private static string GetContentLocation(string contentName)
{
IVsExtensionManager extensionManagerService = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (extensionManagerService == null)
{
return(null);
}
IInstalledExtension dsExt = null;
if (extensionManagerService.TryGetInstalledExtension(GuidList.guidVizMapPkgString, out dsExt) == false)
{
return(null);
}
string contentPath = null;
try
{
string contentRelativePath = dsExt.Content.Where(c => c.ContentTypeName == contentName).First().RelativePath;
contentPath = Path.Combine(dsExt.InstallPath, contentRelativePath);
}
catch { }
return(contentPath);
}
private ExtensionInstalledChecker(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair <string, string> product, DataStore store)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
GalleryEntry entry = null;
try
{
entry = repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
var installable = repository.Download(entry);
manager.Install(installable, false);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
finally
{
if (entry != null)
{
store.PreviouslyInstalledExtensions.Add(entry.VsixID);
}
}
}
private ExtensionInstalledChecker(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
private static bool TryGetRootAndShellFolder(IVsExtensionManager extensionManager, out string shellFolder, out string rootFolder)
{
// use reflection to get this information. currently there is no other way to get this information
shellFolder = GetProperty(extensionManager, "ShellFolder");
rootFolder = GetProperty(extensionManager, "RootFolder");
return !string.IsNullOrEmpty(rootFolder) && !string.IsNullOrEmpty(shellFolder);
}
internal CommandRunner(IConsoleContext consoleContext, IVsExtensionManager extensionManager,
InstalledVersion installedVersion, string rootSuffix)
{
Console = consoleContext;
_extensionManager = extensionManager;
_installedVersion = installedVersion;
_rootSuffix = rootSuffix;
}
private static bool TryGetRootAndShellFolder(IVsExtensionManager extensionManager, out string shellFolder, out string rootFolder)
{
// use reflection to get this information. currently there is no other way to get this information
shellFolder = GetProperty(extensionManager, "ShellFolder");
rootFolder = GetProperty(extensionManager, "RootFolder");
return(!string.IsNullOrEmpty(rootFolder) && !string.IsNullOrEmpty(shellFolder));
}
private IEnumerable <KeyValuePair <string, string> > GetMissingExtensions(IVsExtensionManager manager, DataStore store)
{
var installed = manager.GetInstalledExtensions();
var products = ExtensionList.Products();
var notInstalled = products.Where(product => !installed.Any(ins => ins.Header.Identifier == product.Key)).ToArray();
return(notInstalled.Where(ext => !store.HasBeenInstalled(ext.Key)));
}
private ExtensionInstalledChecker(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
//I have been calling this from the VSPackage's Initilize, passing in the component model
public bool CheckForUpdates(IComponentModel componentModel)
{
_extensionRepository = (IVsExtensionRepository)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsExtensionRepository));
_extensionManager = (IVsExtensionManager)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsExtensionManager));
//Find the extension you're after.
var extension = _extensionManager.GetInstalledExtensions().Where(n => n.Header.Name == "Code Connect Alpha").SingleOrDefault();
return(CheckAndInstallNewVersion(extension));
}
public ExtensionManagerService(IVsExtensionManager obj)
{
if (obj.GetType() != GetRealType())
{
throw new InvalidCastException();
}
Obj = obj;
}
private void GetExtensionManagerIncludeFolders(List <string> includeFolders)
{
IVsExtensionManager service = this.serviceProvider.GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (service != null)
{
includeFolders.AddRange(service.GetEnabledExtensionContentLocations("Microsoft.T4.Include"));
}
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
public static async Task InitializeAsync(AsyncPackage package, IVsExtensionManager extenService)
{
// Switch to the main thread - the call to AddCommand in DisableCommand's constructor requires
// the UI thread.
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken);
OleMenuCommandService commandService = await package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
Instance = new DisableCommand(package, commandService, extenService);
}
public void CheckForUpdates(IVsExtensionManager extensionManager, IVsExtensionRepository repoManager)
{
var plugin = collectionPluginToPluginMapper.MapFrom(GetCollection().plugin);
var updatedExtension = extensionManager.GetInstalledExtensions().FirstOrDefault(x => GlobalConstants.PackageName == x.Header.Name && x.Header.Version < plugin.Version);
if (updatedExtension.IsNotNull())
{
var dialogParameters = dialogMessageEventFactory.GetInstance(packageUpdateManager, updatedExtension, extensionManager, repoManager);
dialogMessagesEvents.OnDialogMessageRequested(this, dialogParameters);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DisableCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="commandService">Command service to add command to, not null.</param>
private DisableCommand(AsyncPackage package, OleMenuCommandService commandService, IVsExtensionManager extenService)
{
this.package = package ?? throw new ArgumentNullException(nameof(package));
_extManager = extenService;
commandService = commandService ?? throw new ArgumentNullException(nameof(commandService));
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.Execute, menuCommandID);
commandService.AddCommand(menuItem);
}
private void Initialize()
{
if (extensionManager == null || Extension == null)
{
extensionManager = serviceProvider.Get <IVsExtensionManager>();
var checkoutAndBuild2Package = serviceProvider.Get <CheckoutAndBuild2Package>();
CurrentVersion = checkoutAndBuild2Package.GetType().Assembly.GetName().Version;
Extension = GetExtension();
ShowVSExtensionManagerCommand = new DelegateCommand <object>(ShowVSExtensionManager);
}
}
private static string GetProperty(IVsExtensionManager extensionManager, string propertyName)
{
try
{
return((string)extensionManager.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance).GetValue(extensionManager));
}
catch
{
return(null);
}
}
/// <summary>
/// Converts the given collection of extension properties and their identifiers to full paths.
/// </summary>
internal static Dictionary<string, string> GetInstalledExtensionPaths(IVsExtensionManager extensionManager, IDictionary<string, string> extensionIds)
{
// Update installed Extensions
var installedExtensionPaths = new Dictionary<string, string>();
extensionIds.ToList().ForEach(ie =>
{
installedExtensionPaths.Add(ie.Key, GetInstalledExtensionPath(extensionManager, ie.Value));
});
return installedExtensionPaths;
}
public void Install(IVsExtensionManager manager, IInstalledExtension currentExtention, IInstallableExtension updatedExtension)
{
manager.Disable(currentExtention);
manager.Uninstall(currentExtention);
manager.Install(updatedExtension, false);
var newlyInstalledVersion = manager.GetInstalledExtension(updatedExtension.Header.Identifier);
if (newlyInstalledVersion.IsNotNull())
{
manager.Enable(newlyInstalledVersion);
}
}
/// <summary>
/// Converts the given collection of extension properties and their identifiers to full paths.
/// </summary>
internal static Dictionary <string, string> GetInstalledExtensionPaths(IVsExtensionManager extensionManager, IDictionary <string, string> extensionIds)
{
// Update installed Extensions
var installedExtensionPaths = new Dictionary <string, string>();
extensionIds.ToList().ForEach(ie =>
{
installedExtensionPaths.Add(ie.Key, GetInstalledExtensionPath(extensionManager, ie.Value));
});
return(installedExtensionPaths);
}
private static string GetInstalledExtensionPath(IVsExtensionManager extensionManager, string extensionId)
{
if (extensionManager != null)
{
IInstalledExtension extension;
if (extensionManager.TryGetInstalledExtension(extensionId, out extension))
{
return(NormalizePathForMsBuild(extension.InstallPath));
}
}
return(null);
}
private static string GetInstalledExtensionPath(IVsExtensionManager extensionManager, string extensionId)
{
if (extensionManager != null)
{
IInstalledExtension extension;
if (extensionManager.TryGetInstalledExtension(extensionId, out extension))
{
return NormalizePathForMsBuild(extension.InstallPath);
}
}
return null;
}
public Version GetCurrentVersion()
{
try
{
// get ExtensionManager
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
// get your extension by Product Id
IInstalledExtension myExtension = manager.GetInstalledExtension("Disasmo.39513ef5-c3ee-4547-b7be-f29c752b591d");
// get current version
Version currentVersion = myExtension.Header.Version;
return(currentVersion);
}
catch { return(new Version(0, 0)); }
}
private ShowSuggestionsCommand(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_package = package;
_repository = repository;
_manager = manager;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(PackageGuids.guidExtensionCmdSet, PackageIds.cmdShowSuggestions);
var button = new OleMenuCommand(async (s, e) => await ShowSuggestions(s, e), menuCommandID);
commandService.AddCommand(button);
}
}
// internal for testing purpose
internal static ImmutableArray<HostDiagnosticAnalyzerPackage> GetHostAnalyzerPackages(IVsExtensionManager extensionManager)
{
var references = ImmutableArray.CreateBuilder<string>();
foreach (var reference in extensionManager.GetEnabledExtensionContentLocations(AnalyzerContentTypeName))
{
if (string.IsNullOrEmpty(reference))
{
continue;
}
references.Add(reference);
}
return ImmutableArray.Create(new HostDiagnosticAnalyzerPackage(name: null, assemblies: references.ToImmutable()));
}
public ProductUpdateService(
IVsExtensionRepository extensionRepository,
IVsExtensionManager extensionManager,
IVsUIShell vsUIShell,
IProductUpdateSettings productUpdateSettings)
{
if (productUpdateSettings == null) {
throw new ArgumentNullException("productUpdateSettings");
}
_vsUIShell = vsUIShell;
_extensionRepository = extensionRepository;
_extensionManager = extensionManager;
_productUpdateSettings = productUpdateSettings;
}
public VS2010UpdateWorker(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
if (extensionManager == null)
{
throw new ArgumentNullException("extensionManager");
}
if (extensionRepository == null)
{
throw new ArgumentNullException("extensionRepository");
}
_extensionManager = extensionManager;
_extensionRepository = extensionRepository;
}
// internal for testing purpose
internal static ImmutableArray<HostDiagnosticAnalyzerPackage> GetHostAnalyzerPackagesWithName(IVsExtensionManager extensionManager, string rootFolder, string shellFolder)
{
var builder = ImmutableArray.CreateBuilder<HostDiagnosticAnalyzerPackage>();
foreach (var extension in extensionManager.GetEnabledExtensions(AnalyzerContentTypeName))
{
var name = extension.Header.LocalizedName;
var assemblies = extension.Content.Where(ShouldInclude)
.Select(c => GetContentLocation(shellFolder, rootFolder, extension.InstallPath, c.RelativePath))
.WhereNotNull();
builder.Add(new HostDiagnosticAnalyzerPackage(name, assemblies.ToImmutableArray()));
}
return builder.ToImmutable();
}
public static void TraceStatisticsHeader(this ITracer traceSource, EnvDTE.DTE dte, IVsExtensionManager extensionManager)
{
traceSource.TraceStatistics("========================= NServiceBusStudio General Information =========================");
traceSource.TraceStatistics("Operating System: {0}", StatisticsInformation.GetOperatingSystemVersion());
traceSource.TraceStatistics("Machine Name: {0}", Environment.MachineName);
traceSource.TraceStatistics("UserName: {0}", Environment.UserName);
traceSource.TraceStatistics("VisualStudio Version: {0}", StatisticsInformation.GetVisualStudioVersion(dte));
traceSource.TraceStatistics("NuPattern Version: {0}", typeof(NuPattern.Guard).AssemblyQualifiedName);
traceSource.TraceStatistics("NServiceBusStudio Version: {0}", typeof(StatisticsInformation).Assembly.FullName);
traceSource.TraceStatistics("Installation Directory: {0}", typeof(StatisticsInformation).Assembly.Location);
traceSource.TraceStatistics("Other Extensions: {0}", String.Join (";", extensionManager.GetEnabledExtensions().Select (x => String.Format ("{0} ({1})", x.Header.Name, x.Header.Version.ToString()))));
traceSource.TraceStatistics("=========================================================================================");
}
private static string GetProperty(IVsExtensionManager extensionManager, string propertyName)
{
try
{
return (string)extensionManager.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance).GetValue(extensionManager);
}
catch
{
return null;
}
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair<string, string> product)
{
try
{
GalleryEntry entry = repository.CreateQuery<GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
Telemetry.TrackEvent(installable.Header.Name);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public Updater(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
_manager = extensionManager;
_repository = extensionRepository;
_checker = new UpdateChecker(extensionRepository, extensionManager);
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new InfoBarService(serviceProvider, repository, manager);
}
public ExtensionInstaller(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
}
public static void Initialize(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ShowSuggestionsCommand(package, repository, manager);
}
public static void Initialize(IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(repository, manager);
}
internal CommandRunner(Version version, string rootSuffix, IVsExtensionManager extensionManager)
{
_version = version;
_rootSuffix = rootSuffix;
_extensionManager = extensionManager;
}
public static IEnumerable<IInstalledExtension> GetExtensions(IVsExtensionManager manager)
{
return from e in manager.GetInstalledExtensions()
where !e.Header.SystemComponent && !e.Header.AllUsers && !e.Header.InstalledByMsi && e.State == EnabledState.Enabled
select e;
}
public ExtensionManagerFacade(IVsExtensionManager visualStudioExtensionManager,
IVsExtensionRepository visualStudioExtensionRepository)
{
ExtensionManager = visualStudioExtensionManager;
ExtensionRepository = visualStudioExtensionRepository;
}
public ExtensionInstaller(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
}
private IEnumerable<KeyValuePair<string, string>> GetMissingExtensions(IVsExtensionManager manager, DataStore store)
{
var installed = manager.GetInstalledExtensions();
var products = ExtensionList.Products();
var notInstalled = products.Where(product => !installed.Any(ins => ins.Header.Identifier == product.Key)).ToArray();
return notInstalled.Where(ext => !store.HasBeenInstalled(ext.Key));
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(serviceProvider, repository, manager);
}
private InfoBarService(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
