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);
}
}
private static bool IsUpToDate(IInstallableExtension installableExtension, IInstalledExtension installedExtension)
{
return
(installedExtension.Header.Version == installableExtension.Header.Version &&
File.GetLastWriteTime(GetManifestPath(installedExtension)) >= File.GetLastWriteTime(installableExtension.PackagePath) &&
installedExtension.InstalledPerMachine == false);
}
private static bool UpdateCanInstalledToCurrentProduct(IInstallableExtension extension)
{
var dte2 = serviceProvider.Get <DTE2>();
var vsVersion = Version.Parse(dte2.Version);
return(extension.References.Any(t => vsVersion >= t.VersionRange.Minimum && vsVersion <= t.VersionRange.Maximum));
}
public void InstallExtension(string vsixPath)
{
if (!Exists())
{
throw new InvalidOperationException("Cannot install VSIX in non-existing instance.");
}
using (var settings = ExternalSettingsManager.CreateForApplication(GetExePath(), Suffix))
{
var ems = new ExtensionManagerService(settings);
IInstallableExtension vsix = ExtensionManagerService.CreateInstallableExtension(vsixPath);
if (ems.IsInstalled(vsix))
{
IInstalledExtension installedVsix = ems.GetInstalledExtension(vsix.Header.Identifier);
ems.Uninstall(installedVsix);
if (ems.IsInstalled(vsix))
{
throw new InvalidOperationException("Could not uninstall already installed GoogleTestAdapter.");
}
}
ems.Install(vsix, perMachine: false);
if (!ems.IsInstalled(vsix))
{
throw new InvalidOperationException("Could not install GoogleTestAdapter.");
}
ems.Close();
}
}
static void Main(string[] args)
{
Log("Starting HostProcess...");
if (args.Length < 2)
{
LogError($"Invalid number of arguments. Expected 3 but was {args.Length}: {string.Join(", ", args)}");
Environment.Exit(-1);
}
string vsixPath = args[0];
string devenvPath = args[1];
string hive = args.Length == 3 ? args[2] : null;
try
{
IInstallableExtension vsix = ExtensionManagerService.CreateInstallableExtension(vsixPath);
if (string.IsNullOrWhiteSpace(hive))
{
hive = "";
}
PerformInstallation(vsix, devenvPath, hive);
}
catch (Exception)
{
Environment.Exit(-1);
}
Log("Exiting HostProcess...");
}
public async Task InstallExtensions(IEnumerable <IExtensionModel> extensionModels)
{
bool hasInstalled = false;
int count = extensionModels.Count();
_progress = new InstallerProgress(count, $"Downloading and installing {count} extension(s)...");
_progress.Show();
await Task.Run(() =>
{
foreach (IExtensionModel model in extensionModels)
{
try
{
GalleryEntry entry = _repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == model.ProductId)
.AsEnumerable()
.FirstOrDefault();
if (!_progress.IsVisible)
{
break;
}
if (entry != null)
{
IInstallableExtension installable = _repository.Download(entry);
if (!_progress.IsVisible)
{
break;
}
_manager.Install(installable, false);
hasInstalled = true;
var props = new Dictionary <string, string> {
{ "extension", model.Name }
};
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
});
if (_progress.IsVisible)
{
_progress.Close();
_progress = null;
}
if (hasInstalled)
{
PromptForRestart();
}
}
public static void Install(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
using (var esm = ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix))
{
var ems = new ExtensionManagerService(esm);
ems.Install(vsix, perMachine: false);
}
}
public static void UpdateExtension(IInstalledExtension extension, IInstallableExtension installableExtension)
{
var extensionManager = serviceProvider.Get <IVsExtensionManager>();
extensionManager.Disable(extension);
extensionManager.Uninstall(extension);
extensionManager.InstallAsync(installableExtension, false);
}
public static void Install(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
using (var esm = ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix))
{
var ems = new ExtensionManagerService(esm);
ems.Install(vsix, perMachine: false);
}
}
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);
}
}
static void Install(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
using (var esm = ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix))
{
var ems = new ExtensionManagerService(esm);
var installed = ems.GetInstalledExtensions().FirstOrDefault(x => x.Header.Identifier == vsix.Header.Identifier);
if (installed != null)
{
ems.Uninstall(installed);
}
ems.Install(vsix, perMachine: false);
}
}
private void InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format(Resources.Text.InstallingExtension, extension.Name));
try
{
Logger.Log($"{Environment.NewLine}{extension.Name}");
Logger.Log(" " + Resources.Text.Verifying, false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
Logger.Log(Resources.Text.Ok); // Marketplace ok
Logger.Log(" " + Resources.Text.Downloading, false);
#if !DEBUG
IInstallableExtension installable = repository.Download(entry);
#endif
Logger.Log(Resources.Text.Ok); // Download ok
Logger.Log(" " + Resources.Text.Installing, false);
#if !DEBUG
manager.Install(installable, false);
#else
Thread.Sleep(2000);
#endif
Logger.Log(Resources.Text.Ok); // Install ok
Telemetry.Install(extension.Id, true);
}
else
{
Logger.Log(Resources.Text.Failed); // Markedplace failed
}
}
catch (Exception)
{
Logger.Log(Resources.Text.Failed);
Telemetry.Install(extension.Id, false);
}
finally
{
if (entry != null)
{
Store.MarkInstalled(extension);
}
}
}
public static void Install(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
using (var esm = ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix))
{
var ems = new ExtensionManagerService(esm);
IInstalledExtension installedVsix = null;
if (ems.TryGetInstalledExtension(vsix.Header.Identifier, out installedVsix))
{
Console.WriteLine($"Extension {vsix.Header.Name} version {vsix.Header.Version} already installed, unistalling first.");
ems.Uninstall(installedVsix);
}
ems.Install(vsix, perMachine: false);
}
}
private void OnNewUpdateFound(IInstallableExtension update)
{
var updateBehavior = settingsService.Get(SettingsKeys.AutoUpdateKey, AutoUpdateBehavior.DownloadAndInstall);
if (updateBehavior == AutoUpdateBehavior.NotificationOnly || (update == null && updateBehavior == AutoUpdateBehavior.DownloadAndInstall))
{
string text = string.Format("There is a new Version of {0} available! [Click here to update](2)", Extension.Header.Name); // (2) is the command parameter
var teamExplorer = serviceProvider.Get <ITeamExplorer>();
teamExplorer.ShowNotification(text, NotificationType.Information, NotificationFlags.RequiresConfirmation, ShowVSExtensionManagerCommand, GuidList.UpdateNotificationId);
}
else if (updateBehavior == AutoUpdateBehavior.DownloadAndInstall && update != null)
{
ExtensionUpdater.UpdateExtension(Extension, update);
}
}
private RestartReason Install(IInstalledExtension currentExtension, IInstallableExtension updatedExtension)
{
//Uninstall old extension
_extensionManager.Disable(currentExtension);
_extensionManager.Uninstall(currentExtension);
//Install new version
var restartReason = _extensionManager.Install(updatedExtension, false);
//Enable the newly installed version of the extension
var newlyInstalledVersion = _extensionManager.GetInstalledExtension(updatedExtension.Header.Identifier);
if (newlyInstalledVersion != null)
{
_extensionManager.Enable(newlyInstalledVersion);
}
return(restartReason);
}
private static IInstalledExtension PerformInstallation(IInstallableExtension vsix, string devenvPath, string hive)
{
IInstalledExtension extension;
using (var settingsManager = ExternalSettingsManager.CreateForApplication(devenvPath, hive))
{
var identifier = vsix.Header.Identifier;
var name = vsix.Header.Name;
Log($"Preparing to install '{name}' with identifier '{identifier}' into '{hive}'");
var extensionManager = new ExtensionManagerService(settingsManager);
if (extensionManager.TryGetInstalledExtension(identifier, out extension))
{
Log($"Extension '{name}' was already installed. Uninstalling...");
try
{
extensionManager.Uninstall(extension);
extensionManager.CommitExternalUninstall(extension);
}
catch (Exception ex)
{
LogError($"An error ocurred while trying to uninstall '{name}'. Rolling back...", ex);
RevertUninstall(extensionManager, extension);
throw;
}
}
try
{
Log($"Starting installation of '{name}'");
extensionManager.Install(vsix, perMachine: false);
extension = extensionManager.GetInstalledExtension(identifier);
Log($"Installation of '{name}' into '{hive}' completed successfully.");
}
catch (Exception ex)
{
LogError($"An error ocurred while trying to install '{name}'. Rolling back...", ex);
RevertUninstall(extensionManager, extension);
throw;
}
}
return(extension);
}
public static bool CheckForUpdate(IInstalledExtension extension, out IInstallableExtension update)
{
var _repository = serviceProvider.Get <IVsExtensionRepository>();
// Find the vsix on the vs gallery
// IMPORTANT: The .AsEnumerble() call is REQUIRED. Don't remove it or the update service won't work.
GalleryEntry entry = _repository.CreateQuery <GalleryEntry>(false, true)
.Where(e => e.VsixID == extension.Header.Identifier)
.AsEnumerable()
.FirstOrDefault();
// If we're running an older version then update
if (entry != null && entry.NonNullVsixVersion > extension.Header.Version)
{
update = _repository.Download(entry);
return(UpdateCanInstalledToCurrentProduct(update));
}
return(CheckForUpdateWithReflection(extension, out update) && UpdateCanInstalledToCurrentProduct(update));
}
public static RestartReason CheckForUpdates(string identifier, string updateUrl)
{
// Don't check for updates on non-DEPLOY builds; the URLs don't work and it seems
// undesirable anyway.
#if DEPLOY
IVsExtensionManager extensionManager = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
IInstalledExtension installedExtension = extensionManager.GetInstalledExtension(identifier);
if (installedExtension == null)
{
throw new Exception(String.Format("Unable to find extension: {0}", identifier));
}
RepositoryEntry entry = new RepositoryEntry();
entry.DownloadUrl = updateUrl;
IVsExtensionRepository repository = Package.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IInstallableExtension latestExtension = repository.Download(entry);
if (latestExtension.Header.Version > installedExtension.Header.Version)
{
RestartReason reason = RestartReason.None;
reason |= extensionManager.Disable(installedExtension);
extensionManager.Uninstall(installedExtension);
try {
reason |= extensionManager.Install(latestExtension, /*perMachine*/ false);
// Enable the new one.
IInstalledExtension latestInstalledExtension = extensionManager.GetInstalledExtension(latestExtension.Header.Identifier);
reason |= extensionManager.Enable(latestInstalledExtension);
return(reason);
} catch {
// Revert the uninstallation.
extensionManager.RevertUninstall(installedExtension);
extensionManager.Enable(installedExtension);
throw;
}
}
#endif
return(RestartReason.None);
}
public void InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format("Installing Extension: ", extension.Name));
try
{
Logger.Log($"{Environment.NewLine}{extension.Name}");
Logger.Log(" " + "Verifying ", false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
Logger.Log("Marketplace OK"); // Marketplace ok
Logger.Log(" " + "Downloading", false);
IInstallableExtension installable = repository.Download(entry);
Logger.Log("Downloading OK"); // Download ok
Logger.Log(" " + "Installing", false);
manager.Install(installable, false);
Logger.Log("Install OK"); // Install ok
Telemetry.Install(extension.Id, true);
}
else
{
Logger.Log("Marketplace failed"); // Markedplace failed
}
}
catch (Exception)
{
Logger.Log("Install failed exception");
Telemetry.Install(extension.Id, false);
}
finally
{
}
}
public bool CheckForUpdate(IInstalledExtension extension, out IInstallableExtension update)
{
// Find the vsix on the vs gallery
// IMPORTANT: The .AsEnumerble() call is REQUIRED. Don't remove it or the update service won't work.
GalleryEntry entry = _repository.CreateQuery<GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == extension.Header.Identifier)
.AsEnumerable()
.FirstOrDefault();
// If we're running an older version then update
if (entry != null && entry.NonNullVsixVersion > extension.Header.Version)
{
update = _repository.Download(entry);
return true;
}
else
{
update = null;
return false;
}
}
protected override ContextMenuStrip CreateMenu()
{
var menuStrip = new ContextMenuStrip();
var item = new ToolStripMenuItem("Copy VSIX ID to Clipboard");
item.Click += (sender, args) =>
{
string path = SelectedItemPaths.FirstOrDefault();
if (string.IsNullOrEmpty(path))
{
return;
}
IInstallableExtension vsix = ExtensionManagerService.CreateInstallableExtension(path);
Clipboard.SetText(vsix.Header.Identifier);
};
menuStrip.Items.Add(item);
return(menuStrip);
}
public bool CheckForUpdate(IInstalledExtension extension, out IInstallableExtension update)
{
// Find the vsix on the vs gallery
// IMPORTANT: The .AsEnumerble() call is REQUIRED. Don't remove it or the update service won't work.
GalleryEntry entry = _repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == extension.Header.Identifier)
.AsEnumerable()
.FirstOrDefault();
// If we're running an older version then update
if (entry != null && entry.NonNullVsixVersion > extension.Header.Version)
{
update = _repository.Download(entry);
return(true);
}
else
{
update = null;
return(false);
}
}
protected override bool CanShowMenu()
{
var paths = SelectedItemPaths.ToArray();
if (paths.Length != 1 ||
Path.GetExtension(paths[0]).ToLowerInvariant() != ".vsix")
{
return(false);
}
try
{
vsix = ExtensionManagerService.CreateInstallableExtension(paths[0]);
}
catch (Exception ex)
{
LogError($"Unable to load the extension '{paths[0]}'", ex);
return(false);
}
return(vsix != null);
}
private void TryInstallVsIntegration([CanBeNull] IVsExtensionManager vsExtensionManager)
{
if (vsExtensionManager == null)
{
return;
}
IInstalledExtension vsIntegrationExtension;
if (vsExtensionManager.TryGetInstalledExtension(VsIntegrationExtensionId, out vsIntegrationExtension))
{
return;
}
FileSystemPath thisAssemblyPath = FileSystemPath.TryParse(typeof(VsIntegrationInstaller).Assembly.Location);
if (thisAssemblyPath.IsNullOrEmpty())
{
return;
}
FileSystemPath vsixPath = thisAssemblyPath.Directory.Combine(VsIntegrationExtensionId + ".vsix");
if (!vsixPath.ExistsFile)
{
MessageBox.ShowInfo("Does not exist: \"{0}\"".FormatEx(vsixPath.FullPath));
return;
}
IInstallableExtension installableExtension = vsExtensionManager.CreateInstallableExtension(vsixPath.FullPath);
RestartReason restartReason = vsExtensionManager.Install(installableExtension, false);
if (restartReason != RestartReason.None)
{
_restartRequired = true;
}
}
private void Query_ExecuteCompleted(object sender, ExecuteCompletedEventArgs e)
{
if (e.Error != null)
{
WriteToOutputPane("Error looking up new extension/s in the gallery...");
_isImportProcessing = false;
return;
}
// Extract results of found extensions
var foundExtensions = e.Results.Cast <GalleryEntry>().ToArray();
var installableExtensions = foundExtensions.Where(entry => _toInstallExtensions.Any(l => l != entry.VsixID)).ToArray();
var missingExtensions = _toInstallExtensions.Except(foundExtensions.Select(fe => fe.VsixID)).ToArray();
if (!installableExtensions.Any())
{
WriteToOutputPane("Couldn't find any of the new extension/s in the gallery.");
_isImportProcessing = false;
return;
}
if (missingExtensions.Any())
{
WriteToOutputPane("Couldn't find " + missingExtensions.Length + " of the new extension/s in the gallery.");
}
// Download and install the new ones
WriteToOutputPane("Installing new extension/s:");
var wasAnInstallSuccessful = false;
foreach (var installableExtension in installableExtensions)
{
var msg = string.Format(" - '{0}' ", installableExtension.Name);
IInstallableExtension extension = null;
try
{
extension = _repository.Download(installableExtension);
_manager.Install(extension, false);
msg += "installed.";
wasAnInstallSuccessful = true;
}
catch (Exception ex)
{
msg += "install failed. " + ex.Message;
}
WriteToOutputPane(msg);
}
if (wasAnInstallSuccessful)
{
WriteToOutputPane(Environment.NewLine + Environment.NewLine + "Please restart for changes to take affect.");
}
WriteToOutputPane("Extensions imported.");
// Reset
_isImportProcessing = false;
_toInstallExtensions = new string[] { };
}
static void Install(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
using (var esm = ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix))
{
var ems = new ExtensionManagerService(esm);
var installed = ems.GetInstalledExtensions().FirstOrDefault(x => x.Header.Identifier == vsix.Header.Identifier);
if (installed != null)
ems.Uninstall(installed);
ems.Install(vsix, perMachine: false);
}
}
public static void InstallIntoDefaultRoot(string vsExe, IInstallableExtension vsix)
{
Install(vsix, () => ExternalSettingsManager.CreateForApplication(vsExe));
}
public static void InstallIntoCustomRoot(string vsExe, IInstallableExtension vsix, string rootSuffix)
{
Install(vsix, () => ExternalSettingsManager.CreateForApplication(vsExe, rootSuffix));
}
public static void Install(IInstallableExtension vsix, Func<ExternalSettingsManager> GetExternalSettingsManager)
{
using (var externalSettingsManager = GetExternalSettingsManager())
{
(new ExtensionManagerService(externalSettingsManager)).Install(vsix, perMachine: false);
}
}
private async System.Threading.Tasks.Task ExtMgrInstallExtensionAsync()
{
GalleryEntry entry = null;
try
{
// Waits for MEF to initialize before the extension manager is ready to use
var scComponentModel = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SComponentModel));
IVsExtensionRepository repository = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IVsExtensionManager manager = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
Logger.Log($"{Environment.NewLine}{this.Extension.Title}");
Logger.Log(" " + "Verifying ", false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new System.Collections.Generic.List <string> {
this.Extension.VsixId.ToString()
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
// ensure that we update the URL if it is empty
if (entry.DownloadUrl == null)
{
entry.DownloadUrl = this.Extension.Installer;
throw new Exception("This is not a VsiX");
}
Logger.Log("Marketplace OK"); // Marketplace ok
Logger.Log(" " + "Downloading");
IInstallableExtension installable = repository.Download(entry);
if (installable == null)
{
throw new Exception("This is not a VsiX");
}
Logger.Log("Downloading OK"); // Download ok
Logger.Log(" " + "Installing");
manager.Install(installable, false);
Logger.Log("Installation queued OK"); // Install ok
Logger.Log("This extension package will now be automatically installed when you exist all instances of Visual Studio");
}
else
{
Logger.Log("Marketplace failed"); // Markedplace failed
// This is not a VsiX
throw new Exception("This is not a VsiX");
Logger.Log("Done");
}
}
catch (Exception ex)
{
Logger.Log("Extension Manager installtion failed exception: " + ex);
Logger.Log("Trying manual downloand and install");
await this.ManualInstallExtensionAsync();
}
finally
{
await System.Threading.Tasks.Task.Yield();
}
}
private RestartReason InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format("{0} ({1})", _settings.ResourceProvider.InstallingExtension, extension.Name));
var ret = RestartReason.None;
try
{
_logger.Log($"{Environment.NewLine}{extension.Name}");
_logger.Log(" " + _settings.ResourceProvider.Verifying, false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
_logger.Log(_settings.ResourceProvider.Ok); // Marketplace ok
#if DEBUG || true
var extensionsByAuthor = manager.GetInstalledExtensions().GroupBy(x => x.Header.Author).Select(y => new { y.Key, items = y }).ToArray();
#endif
var installed = manager.GetInstalledExtensions().SingleOrDefault(n => n.Header.Identifier == extension.Id);
_logger.Log(" " + _settings.ResourceProvider.Verifying, false);
IInstallableExtension installable = null;
if (installed != null)
{
if (NewerVersionExists(installed, repository, entry))
{
installed = null;
}
}
_logger.Log(" " + _settings.ResourceProvider.Ok);
if (installed == null)
{
_logger.Log(" " + _settings.ResourceProvider.Downloading, false);
installable = repository.Download(entry);
_logger.Log(_settings.ResourceProvider.Ok); // Download ok
}
if (installable == null)
{
_logger.Log(" nothing to do");
}
else
{
_logger.Log(" " + _settings.ResourceProvider.Installing, false);
ret = manager.Install(installable, false);
_logger.Log(_settings.ResourceProvider.Ok); // Install ok
}
Telemetry.Install(extension.Id, true);
}
else
{
_logger.Log(_settings.ResourceProvider.Failed); // Markedplace failed
}
}
catch (Exception e)
{
_logger.Log(_settings.ResourceProvider.Failed);
_logger.Log("Failed to install package: " + e.Message);
_log.Error(e);
Telemetry.Install(extension.Id, false);
}
finally
{
if (entry != null)
{
Store.MarkInstalled(extension);
}
}
return(ret);
}
private static bool CheckForUpdateWithReflection(IInstalledExtension extension, out IInstallableExtension update)
{
var _repository = serviceProvider.Get <IVsExtensionRepository>();
update = null;
var extensionRepositoryService = serviceProvider.Get <IVsExtensionRepository>();
var methodInfo = extensionRepositoryService.GetType().GetMethod("GetRepositories");
if (methodInfo != null)
{
IEnumerable <IInstalledExtension> extensionsToCheck = new List <IInstalledExtension> {
extension
};
var repositories = methodInfo.Invoke(extensionRepositoryService, new object[0]) as IEnumerable <object>;
if (repositories != null)
{
var onlineExtension = ((from repository in repositories.ToList()
let getUpdateMethod = repository.GetType().GetMethod("GetUpdates")
where getUpdateMethod != null
let repo = repository
select Check.TryCatch <IEnumerable <object>, Exception>(() => getUpdateMethod.Invoke(repo, new object[] { extensionsToCheck }) as IEnumerable <object>)
into possibleUpdates
where possibleUpdates != null
select possibleUpdates.FirstOrDefault())).ToList().OfType <IVsExtension>().FirstOrDefault();
{
if (onlineExtension != null)
{
bool isAllreadyInstalled = onlineExtension.GetType().GetProperty("UpdateIsInstalled").GetValue(onlineExtension) as bool? ?? false;
if (!isAllreadyInstalled)
{
var updateEntry = onlineExtension.GetType().GetProperty("UpdateEntry").GetValue(onlineExtension) as IRepositoryEntry;
if (updateEntry != null)
{
update = _repository.Download(updateEntry);
}
return(true);
}
}
}
}
}
return(false);
}
public RestartReason Install(IInstallableExtension extension, bool perMachine)
{
throw new NotImplementedException();
}
public void InstallAsync(IInstallableExtension extension, bool perMachine)
{
throw new NotImplementedException();
}