示例#1
0
        private static string GetLatestAvailableTypeScriptVersionFromSetup()
        {
            var setupCompositionService = (IVsSetupCompositionService)CommonPackage.GetGlobalService(typeof(SVsSetupCompositionService));

            // Populate the package status
            uint count      = 0;
            uint sizeNeeded = 0;

            IVsSetupPackageInfo[] packages = null;
            setupCompositionService.GetSetupPackagesInfo(count, packages, out sizeNeeded);

            if (sizeNeeded > 0)
            {
                packages = new IVsSetupPackageInfo[sizeNeeded];
                count    = sizeNeeded;
                setupCompositionService.GetSetupPackagesInfo(count, packages, out sizeNeeded);

                return(packages.Where(p => (__VsSetupPackageState)p.CurrentState == __VsSetupPackageState.INSTALL_PACKAGE_PRESENT)
                       .Select(p => p.PackageId)
                       .Where(p => p.StartsWith(tsSdkSetupPackageIdPrefix))
                       .Select(p => p.Substring(tsSdkSetupPackageIdPrefix.Length, p.Length - tsSdkSetupPackageIdPrefix.Length))
                       .OrderByDescending(v => v)
                       .First());
            }

            return("");
        }
        private static IVsSetupPackageInfo[] GetPackages(IVsSetupCompositionService setupService)
        {
            if (setupService != null)
            {
                // Get the count
                setupService.GetSetupPackagesInfo(0, null, out uint count);

                // Get the data
                var buffer = new IVsSetupPackageInfo[count];
                setupService.GetSetupPackagesInfo(count, buffer, out uint actual);

                // Extra safety in case count changed between the 2 calls
                return(buffer.Take((int)Math.Min(actual, count)).ToArray());
            }
            else
            {
                return(new IVsSetupPackageInfo[0]);
            }
        }
示例#3
0
        private static string GetLatestAvailableTypeScriptVersionFromSetup()
        {
            var setupCompositionService = (IVsSetupCompositionService)Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsSetupCompositionService));

            // Populate the package status
            setupCompositionService.GetSetupPackagesInfo(0, null, out var sizeNeeded);

            if (sizeNeeded > 0)
            {
                var packages = new IVsSetupPackageInfo[sizeNeeded];
                setupCompositionService.GetSetupPackagesInfo(sizeNeeded, packages, out _);

                var typeScriptSdkPackageGroups = packages.Where(p => p.PackageId.StartsWith(tsSdkSetupPackageIdPrefix, StringComparison.OrdinalIgnoreCase))
                                                 .GroupBy(p => p.CurrentState, p => p.PackageId);

                var installed = typeScriptSdkPackageGroups.Where(g => g.Key == (uint)__VsSetupPackageState.INSTALL_PACKAGE_PRESENT);
                if (installed.Any())
                {
                    return(GetVersion(installed.First()));
                }

                // There is an issue in the installer where components aren't registered as 'Present', however they do show up as unknown.
                // So use that as a fallback.
                var unknown = typeScriptSdkPackageGroups.Where(g => g.Key == (uint)__VsSetupPackageState.INSTALL_PACKAGE_UNKNOWN);
                if (unknown.Any())
                {
                    return(GetVersion(unknown.First()));
                }

                // This should not happen, since TS should be installed as a required component, however we should guard against
                // bugs in the installer, and use a good default for the user.
                Debug.Fail("Failed to find a valid install of the TypeScript SDK.");
            }

            return("");

            string GetVersion(IEnumerable <string> installed)
            {
                return(installed.Select(p => p.Substring(tsSdkSetupPackageIdPrefix.Length, p.Length - tsSdkSetupPackageIdPrefix.Length))
                       .OrderByDescending(v => v)
                       .First());
            }
        }