private void NugetEvents_PackageInstalled(IVsPackageMetadata metadata)
 {
     //有可能出现这种情况:解决方案已经加载完成了,还没加载此包,
     //导致在解决方案加载完整事件时,不能更新所有项目的引用包
     //所以在这里更新包一次
     PackageHelper.UpdateAllPackagesOfAllProjects();
 }
Пример #2
0
        // The parameter 'latestKnownAssemblyVersion' can be null and if yes will be
        // infered from 'assemblyReferenceName' parameter.
        // I added that as a parameter to make unit testing easier.
        internal static void GetPackageFileNameForPackage(CodeGenerationContext context, IEnumerable <IVsPackageMetadata> installedPackages, string packageId, string assemblyReferenceName, Version minSupportedAssemblyReferenceVersion, ref string packageFileName)
        {
            if (ProjectReferences.IsAssemblyReferenced(context.ActiveProject, assemblyReferenceName))
            {
                // If the project has reference to MVC version 5.0 or
                // above the corresponding package versions file is loaded from the file system.
                IVsPackageMetadata installedPackage = installedPackages
                                                      .Where(package => String.Equals(packageId, package.Id, StringComparison.OrdinalIgnoreCase))
                                                      .FirstOrDefault();

                Version versionForPackageFile;
                // First try to get the package version and if not fallback to assembly reference version.
                if (installedPackage == null || !SemanticVersionParser.TryParse(installedPackage.VersionString, out versionForPackageFile))
                {
                    // Note: In this scenario where user does not have a package
                    // reference but only has assembly reference, we will end up
                    // using 5.1.0 instead of 5.1.1 version of package file (even
                    // if the assembly reference is the same as the one shipped in 5.1.1)
                    // because the assembly version did not change for 5.1.1
                    versionForPackageFile = ProjectReferences.GetAssemblyVersion(context.ActiveProject, assemblyReferenceName);
                }

                // Version should have been either available from package or atleast the assembly reference.
                Contract.Assert(versionForPackageFile != null);

                // For example : If 5.1 is the latest tooling version and if we release just the NuGet packages for a higher version of runtime (may be 5.2),
                // we will still continue to scaffold the latest tooling version (in this case 5.1).
                if (versionForPackageFile >= minSupportedAssemblyReferenceVersion && versionForPackageFile <= _latestKnownPackageVersion)
                {
                    packageFileName = GetPackageVersionsFileName(versionForPackageFile);
                }
            }
        }
Пример #3
0
 private void PackageInstallerEvents_PackageInstalled(IVsPackageMetadata metadata)
 {
     if (BatchEnd != null)
     {
         BatchEnd();
     }
 }
Пример #4
0
        protected internal virtual void OnPackageInstalled(IVsPackageMetadata metadata)
        {
            var handler = PackageInstalled;
            if (handler == null)
                return;

            handler(metadata);
        }
Пример #5
0
        private bool AuditPackageInternal(IVsPackageMetadata package)
        {
            var packageId = new PackageId(package.Id, package.VersionString);

            WriteLine(Resources.AuditingPackage, packageId);

            return(AuditPackagesInternal(new[] { packageId }));
        }
Пример #6
0
        private void nugetEvents_PackageReferenceAdded(IVsPackageMetadata metadata)
        {
            //Debug
            Debug.WriteLine(string.Format("Umbraco New Project - PackageReferencedAdded() event {0} {1}", metadata.Title, metadata.VersionString));

            //Update IDE status bar bottom left
            _dte.StatusBar.Text = string.Format("Umbraco New Project - Adding Nuget Package Reference {0} {1}", metadata.Title, metadata.VersionString);
        }
Пример #7
0
        public string GetNugetVersion(Project prj, string pkgName)
        {
            IVsPackageMetadata m_data = this.GetNugetMetadata(prj, pkgName);

            if (m_data != null)
            {
                return(m_data.VersionString);
            }

            return(string.Empty);
        }
Пример #8
0
 private void PackageInstallerEvents_PackageInstalled(IVsPackageMetadata metadata)
 {
     ThreadHelper.JoinableTaskFactory.Run(async() =>
     {
         await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
         if (BatchEnd != null)
         {
             BatchEnd();
         }
     });
 }
Пример #9
0
        protected internal virtual void OnPackageReferenceAdded(IVsPackageMetadata metadata)
        {
            var handler = PackageReferenceAdded;

            if (handler == null)
            {
                return;
            }

            handler(metadata);
        }
Пример #10
0
        protected internal virtual void OnPackageInstalling(IVsPackageMetadata metadata)
        {
            var handler = PackageInstalling;

            if (handler == null)
            {
                return;
            }

            handler(metadata);
        }
Пример #11
0
 private void BindPackage(IVsPackageMetadata package)
 {
     try
     {
         if (Binder.Execute(package.InstallPath))
             PrintToOutputWindow(string.Format("{0}{1} locaolized Complete.\r\n", package.Id, package.VersionString));
     }
     catch (Exception ex)
     {
         PrintToOutputWindow(string.Format("{0}{1} locaolized fail: {2}\r\n", package.Id, package.VersionString, ex.Message));
     }
 }
Пример #12
0
        private void InstallerEvents_PackageInstalled(IVsPackageMetadata metadata)
        {
            _backgroundQueue.QueueTask(async() => {
                var asyncTask = TTasks.Task.Factory.StartNew(() => {
                    return(AuditPackageInternal(metadata));
                }, CancellationToken.None, TTasks.TaskCreationOptions.None, _uiTaskScheduler);

                while (!await asyncTask)
                {
                    TTasks.Task.Delay(TimeSpan.FromSeconds(5)).Wait();
                }
            });
        }
Пример #13
0
        private void OnPackageInstalled(IVsPackageMetadata metadata)
        {
            // Fire and forget. When new package is installed, we are not just adding this package to the index,
            // but instead we attempt full sync. Full sync in this case would only sync new packages that don't
            // exist in the index which should be fast. The reason for full sync is that when there are several
            // instances of VS and each tries to update index at the same tiime, only one would succeed, other
            // would notive that index is locked and skip this operation. Thus if all VS instances attempt full
            // sync at least one of them would do it and add all new packages to the index.
            var indexFactory = new PackageIndexFactory();
            var builder      = indexFactory.GetLocalIndexBuilder();

            builder.BuildAsync(newOnly: true);
        }
        public void GetInstalledPackages_OneInstalledPackages_ReturnsOnePackage()
        {
            CreatePackageInstallerServices();
            string   installPath      = @"d:\projects\MyProject\packages\TestPackage";
            IPackage installedPackage = AddPackage("Id", "1.1", installPath);

            List <IVsPackageMetadata> packages = installerServices.GetInstalledPackages().ToList();

            IVsPackageMetadata package = packages[0];

            Assert.AreEqual(1, packages.Count);
            Assert.AreEqual("Id", package.Id);
            Assert.AreEqual("1.1", package.Version.ToString());
            Assert.AreEqual(@"d:\projects\MyProject\packages\TestPackage", package.InstallPath);
        }
        private bool IsSlowCheetahUpdated(Project project)
        {
            // Checks for older SC versions that require more complex update procedure.
            IVsPackageInstallerServices installerServices = GetInstallerServices(this.package);
            IVsPackageMetadata          scPackage         =
                installerServices.GetInstalledPackages().FirstOrDefault(pkg => string.Equals(pkg.Id, PackageName, StringComparison.OrdinalIgnoreCase));

            if (scPackage != null)
            {
                if (Version.TryParse(scPackage.VersionString, out Version ver))
                {
                    return(ver > LastUnsupportedVersion);
                }
            }

            return(false);
        }
Пример #16
0
 private void OnPackageReferenceAdded(IVsPackageMetadata metadata)
 {
     if (IsCurrentSolutionEnabledForRestore)
     {
         var packageMetadata = (VsPackageMetadata)metadata;
         var fileSystem      = packageMetadata.FileSystem as IVsProjectSystem;
         if (fileSystem != null)
         {
             var project = _solutionManager.GetProject(fileSystem.UniqueName);
             if (project != null)
             {
                 // in this case, we know that this project has at least one nuget package,
                 // so enable package restore straight away
                 EnablePackageRestore(project);
             }
         }
     }
 }
Пример #17
0
        /// <summary>
        /// Gets the generator for the given project
        /// </summary>
        /// <param name="proj">The project</param>
        /// <returns>the associated import generator</returns>
        public static ImportedGenerator GetForProj(Project proj)
        {
#if DEBUG
            return(s_imports.GetOrAdd("Debug", (dontcare) =>
            {
                return new ImportedGenerator(CacheBasePath, "Debug", "");
            }));
#else
            IVsPackageMetadata pkg = GetInstalledPackageMetadata(proj);
            if (pkg == null)
            {
                return(null);
            }
            return(s_imports.GetOrAdd(pkg.VersionString, (dontcare) =>
            {
                return new ImportedGenerator(CacheBasePath, pkg.VersionString, pkg.InstallPath);
            }));
#endif
        }
Пример #18
0
        internal static void GetPackageFileNameForPackage(CodeGenerationContext context, IEnumerable <IVsPackageMetadata> installedPackages, string packageId, string assemblyReferenceName, Version minSupportedAssemblyReferenceVersion, ref string packageFileName)
        {
            Version assemblyVersion;

            if (ProjectReferences.IsAssemblyReferenced(context.ActiveProject, assemblyReferenceName))
            {
                IVsPackageMetadata variable = (
                    from package in installedPackages
                    where string.Equals(packageId, package.Id, StringComparison.OrdinalIgnoreCase)
                    select package).FirstOrDefault <IVsPackageMetadata>();
                if (variable == null || !SemanticVersionParser.TryParse(variable.VersionString, out assemblyVersion))
                {
                    assemblyVersion = ProjectReferences.GetAssemblyVersion(context.ActiveProject, assemblyReferenceName);
                }
                if (assemblyVersion >= minSupportedAssemblyReferenceVersion && assemblyVersion <= PackageVersions._latestKnownPackageVersion)
                {
                    packageFileName = PackageVersions.GetPackageVersionsFileName(assemblyVersion);
                }
            }
        }
Пример #19
0
        private static Version GetNuGetPackageVersion(IVsPackageMetadata package)
        {
            Version version;
            string  versionString = package.VersionString;
            int     dashIndex     = versionString.IndexOf('-');

            if (dashIndex != -1)
            {
                // Trim off any pre-release versions.  Because the handler should never install pre-release
                // versions they can be ignored when comparing versions.
                versionString = versionString.Substring(0, dashIndex);
            }

            if (!Version.TryParse(versionString, out version))
            {
                Debug.Fail("Unable to parse the NuGet package version " + versionString);
            }

            return(version);
        }
Пример #20
0
            private void addExtension(IVsPackageMetadata package)
            {
                //td: determine if the package is installed in this project


                var toolPath = Path.Combine(package.InstallPath, "tools");

                if (!Directory.Exists(toolPath))
                {
                    return; //td: ask to restore packages
                }
                var dlls = Directory.EnumerateFiles(toolPath)
                           .Where(file => Path.GetExtension(file) == ".dll");

                foreach (var dll in dlls)
                {
                    var fileName = Path.GetFileName(dll);
                    if (!fileName.StartsWith("Excess."))
                    {
                        continue; //convention over configuration?
                    }
                    var assembly = Assembly.LoadFrom(dll);
                    if (assembly == null)
                    {
                        continue;
                    }

                    //var extension = loadReference(dll, name);
                    var name      = string.Empty;
                    var extension = Loader <RoslynCompiler> .CreateFrom(assembly, out name);

                    if (extension != null)
                    {
                        _extensions[name] = extension;
                    }
                }
            }
Пример #21
0
        /// <summary>
        /// Uninstall the packages that exist in the project.
        /// </summary>
        public static async Task UninstallPackagesAsync(
            Project targetProject,
            ISet <string> packages,
            Func <string, Task> uninstallPackage,
            ConnectedServiceLogger logger,
            IVsPackageInstallerServices packageInstallerServices)
        {
            IEnumerable <IVsPackageMetadata> installedPackages = packageInstallerServices.GetInstalledPackages(targetProject);

            foreach (string packageId in packages)
            {
                IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == packageId);
                if (installedPackage != null)
                {
                    await logger.WriteMessageAsync(
                        LoggerMessageCategory.Information,
                        Resource.LogMessage_RemovingNuGetPackage,
                        packageId,
                        installedPackage.VersionString);

                    await uninstallPackage(packageId);
                }
            }
        }
Пример #22
0
        private async Task AddNuGetPackagesAsync(ConnectedServiceHandlerContext context, Project project)
        {
            IEnumerable <IVsPackageMetadata> installedPackages = this.PackageInstallerServices.GetInstalledPackages(project);
            Dictionary <string, string>      packagesToInstall = new Dictionary <string, string>();

            foreach (Tuple <string, Version> requiredPackage in SalesforceConnectedServiceHandler.requiredPackages)
            {
                IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == requiredPackage.Item1);
                if (installedPackage == null)
                {
                    // The package does not exist - notify and install the package.
                    await context.Logger.WriteMessageAsync(
                        LoggerMessageCategory.Information,
                        Resources.LogMessage_AddingNuGetPackage,
                        requiredPackage.Item1,
                        requiredPackage.Item2.ToString());
                }
                else
                {
                    Version installedVersion = SalesforceConnectedServiceHandler.GetNuGetPackageVersion(installedPackage);
                    if (installedVersion == null)
                    {
                        // Unable to parse the version - continue.
                        continue;
                    }
                    else if (installedVersion.Major < requiredPackage.Item2.Major)
                    {
                        // An older potentially non-compatible version of the package already exists - warn and upgrade the package.
                        await context.Logger.WriteMessageAsync(
                            LoggerMessageCategory.Warning,
                            Resources.LogMessage_OlderMajorVersionNuGetPackageExists,
                            requiredPackage.Item1,
                            installedPackage.VersionString,
                            requiredPackage.Item2.ToString());
                    }
                    else if (installedVersion.Major > requiredPackage.Item2.Major)
                    {
                        // A newer potentially non-compatible version of the package already exists - warn and continue.
                        await context.Logger.WriteMessageAsync(
                            LoggerMessageCategory.Warning,
                            Resources.LogMessage_NewerMajorVersionNuGetPackageExists,
                            requiredPackage.Item1,
                            requiredPackage.Item2.ToString(),
                            installedPackage.VersionString);

                        continue;
                    }
                    else if (installedVersion >= requiredPackage.Item2)
                    {
                        // A newer semantically compatible version of the package already exists - continue.
                        continue;
                    }
                    else
                    {
                        // An older semantically compatible version of the package exists - notify and upgrade the package.
                        await context.Logger.WriteMessageAsync(
                            LoggerMessageCategory.Information,
                            Resources.LogMessage_UpgradingNuGetPackage,
                            requiredPackage.Item1,
                            installedPackage.VersionString,
                            requiredPackage.Item2.ToString());
                    }
                }

                packagesToInstall.Add(requiredPackage.Item1, requiredPackage.Item2.ToString());
            }

            if (packagesToInstall.Any())
            {
                this.PackageInstaller.InstallPackagesFromVSExtensionRepository(
                    "Salesforce.VisualStudio.Services.B161EEC7-17E0-4C35-AF8D-F241325BDD1C",
                    false,
                    false,
                    project,
                    packagesToInstall);
            }
        }
Пример #23
0
 public NugetPackageToolImporter(Project proj, string cacheBasePath)
     : base(cacheBasePath)
 {
     _pkg = GetInstalledPackageMetadata(proj);
 }
Пример #24
0
 private void OnEventsOnPackageInstalling(IVsPackageMetadata m)
 {
     m_outputWindowPane.OutputStringThreadSafe($"Installing package {m.Id}, version {m.VersionString}.");
 }
        private GraphNode GetOrCreatePackageNode(IGraphContext context, GraphNode parent, IVsPackageMetadata package)
        {
            var parentId = parent.GetValue <GraphNodeId>("Id");
            var nodeId   = GraphNodeId.GetNested(
                parentId,
                GraphNodeId.GetPartial(CodeGraphNodeIdName.Member, package.Id),
                GraphNodeId.GetPartial(CodeGraphNodeIdName.Parameter, package.VersionString));
            var node = context.Graph.Nodes.Get(nodeId);

            if (node == null)
            {
                using (var scope = new GraphTransactionScope())
                {
                    node = context.Graph.Nodes.GetOrCreate(nodeId, package.Id, ReferencesGraphSchema.PackageCategory);

                    node.SetValue <string>(DgmlNodeProperties.Icon, GraphIcons.Package);
                    node.SetValue <IVsPackageMetadata>(ReferencesGraphSchema.PackageProperty, package);

                    // Establish the relationship with the parent node.
                    context.Graph.Links.GetOrCreate(parent, node, null, GraphCommonSchema.Contains);

                    context.OutputNodes.Add(node);
                    scope.Complete();
                }
            }

            return(node);
        }
Пример #26
0
 void packageEvents_PackageReferenceAdded(IVsPackageMetadata metadata)
 {
     BindPackage(metadata);
 }
 private void ResetAnalyzersCache(IVsPackageMetadata metadata)
 {
     this.groupingEvent.FireIncoming();
 }
Пример #28
0
        internal void ReportPackageReferenceAddedProgress(uint prog, IVsPackageMetadata metadata)
        {
            var msg = string.Format(PrigResources.GetString("ReferenceAdded_0_MessageFormat"), metadata.Id);

            Statusbar.ReportProgress(msg, prog);
        }
Пример #29
0
 internal void ReportPackageInstallingProgress(uint prog, IVsPackageMetadata metadata)
 {
     var msg = string.Format(PrigResources.GetString("Installing_0_MessageFormat"), metadata.Id);
     Statusbar.ReportProgress(msg, prog);
 }
Пример #30
0
        private void RecalcInstalledPackages(IVsPackageMetadata metadata)
        {
            if (!IsNuGetAvailable || solution.IsTemporary)
            {
              lock (syncObject)
              {
                installedPackages = emptyLookup;
              }
              return;
            }

            try
            {
              lock (syncObject)
              {
                installedPackages = ToLookup(vsPackageInstallerServices.GetInstalledPackages());
              }
            }
            catch (Exception ex)
            {
              installedPackages = emptyLookup;
              Logger.LogException("RecalcInstalledPackages", ex);
            }
        }
Пример #31
0
        private void nugetEvents_PackageReferenceAdded(IVsPackageMetadata metadata)
        {
            //Debug
            Debug.WriteLine(string.Format("Umbraco New Project - PackageReferencedAdded() event {0} {1}", metadata.Title, metadata.VersionString));

            //Update IDE status bar bottom left
            _dte.StatusBar.Text = string.Format("Umbraco New Project - Adding Nuget Package Reference {0} {1}", metadata.Title, metadata.VersionString);
        }
Пример #32
0
        /// <summary>
        /// Ensures the appropriate version of the specified packages are installed.  If an existing version of the package
        /// already exists the following will happen:
        /// If a semantically compatible version already exists, no change is made to the package.
        /// If an older major version exists, a warning is logged and the package is upgraded.
        /// If an older minor/build version exists, an information message is logged and the package is upgraded.
        /// If a newer major version exists, a warning is logged and no change is made to the package.
        /// </summary>
        public static async Task InstallPackagesAsync(
            Project targetProject,
            Dictionary <string, string> packages,
            Func <string, string, Task> installPackage,
            ConnectedServiceLogger logger,
            IVsPackageInstallerServices packageInstallerServices)
        {
            IEnumerable <IVsPackageMetadata> installedPackages;

            try
            {
                installedPackages = packageInstallerServices.GetInstalledPackages(targetProject);
            }
            catch (ArgumentException)
            {
                // This happens for C++ projects
                installedPackages = new List <IVsPackageMetadata>();
            }

            foreach (KeyValuePair <string, string> requiredPackage in packages)
            {
                IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == requiredPackage.Key);
                if (installedPackage == null)
                {
                    // The package does not exist - notify and install the package.
                    await logger.WriteMessageAsync(
                        LoggerMessageCategory.Information,
                        Resource.LogMessage_AddingNuGetPackage,
                        requiredPackage.Key,
                        requiredPackage.Value);
                }
                else
                {
                    Version installedVersion = NuGetUtilities.GetVersion(installedPackage.VersionString);
                    Version requiredVersion  = NuGetUtilities.GetVersion(requiredPackage.Value);
                    if (installedVersion == null || requiredVersion == null)
                    {
                        // Unable to parse the version - continue.
                        continue;
                    }
                    else if (installedVersion.Major < requiredVersion.Major)
                    {
                        // An older potentially non-compatible version of the package already exists - warn and upgrade the package.
                        await logger.WriteMessageAsync(
                            LoggerMessageCategory.Warning,
                            Resource.LogMessage_OlderMajorVersionNuGetPackageExists,
                            requiredPackage.Key,
                            installedPackage.VersionString,
                            requiredPackage.Value);
                    }
                    else if (installedVersion.Major > requiredVersion.Major)
                    {
                        // A newer potentially non-compatible version of the package already exists - warn and continue.
                        await logger.WriteMessageAsync(
                            LoggerMessageCategory.Warning,
                            Resource.LogMessage_NewerMajorVersionNuGetPackageExists,
                            requiredPackage.Key,
                            requiredPackage.Value,
                            installedPackage.VersionString);

                        continue;
                    }
                    else if (installedVersion >= requiredVersion)
                    {
                        // A semantically compatible version of the package already exists - continue.
                        continue;
                    }
                    else
                    {
                        // An older semantically compatible version of the package exists - notify and upgrade the package.
                        await logger.WriteMessageAsync(
                            LoggerMessageCategory.Information,
                            Resource.LogMessage_UpgradingNuGetPackage,
                            requiredPackage.Key,
                            installedPackage.VersionString,
                            requiredPackage.Value);
                    }
                }

                await installPackage(requiredPackage.Key, requiredPackage.Value);
            }
        }
 private void OnPackageReferenceAdded(IVsPackageMetadata metadata)
 {
     if (IsCurrentSolutionEnabledForRestore)
     {
         var packageMetadata = (VsPackageMetadata)metadata;
         var fileSystem = packageMetadata.FileSystem as IVsProjectSystem;
         if (fileSystem != null)
         {
             var project = _solutionManager.GetProject(fileSystem.UniqueName);
             if (project != null)
             {
                 // in this case, we know that this project has at least one nuget package,
                 // so enable package restore straight away
                 EnablePackageRestore(project);
             }
         }
     }
 }
Пример #34
0
 internal void ReportPackageReferenceAddedProgress(uint prog, IVsPackageMetadata metadata)
 {
     var msg = string.Format(PrigResources.GetString("ReferenceAdded_0_MessageFormat"), metadata.Id);
     Statusbar.ReportProgress(msg, prog);
 }
Пример #35
0
        internal void ReportPackageInstallingProgress(uint prog, IVsPackageMetadata metadata)
        {
            var msg = string.Format(PrigResources.GetString("Installing_0_MessageFormat"), metadata.Id);

            Statusbar.ReportProgress(msg, prog);
        }
Пример #36
0
        private bool AuditPackageInternal(IVsPackageMetadata package)
        {
            var packageId = new PackageId(package.Id, package.VersionString);

            WriteLine(Resources.AuditingPackage, packageId);

            return AuditPackagesInternal(new[] { packageId });
        }
Пример #37
0
        private void InstallerEvents_PackageReferenceAdded(IVsPackageMetadata metadata)
        {
            _backgroundQueue.QueueTask(async () =>
            {
                var asyncTask = TTasks.Task.Factory.StartNew(() =>
                {
                    return AuditPackageInternal(metadata);
                }, CancellationToken.None, TTasks.TaskCreationOptions.None, _uiTaskScheduler);

                while (!await asyncTask)
                {
                    TTasks.Task.Delay(TimeSpan.FromSeconds(5)).Wait();
                }
            });
        }
Пример #38
0
 private void InstallerEvents_PackageReferenceRemoved(IVsPackageMetadata metadata)
 {
     _backgroundQueue.QueueTask(() => {
         RefreshTasks();
     }, _uiTaskScheduler);
 }
Пример #39
0
 public static void FixPackagePathsAndSaveProject(EnvDTE.Project project, IVsPackageMetadata package, string solutionDir)
 {
     FixPackagePathsAndSaveProject(project, new[] { package }, solutionDir);
 }
Пример #40
0
 private void InstallerEvents_PackageReferenceRemoved(IVsPackageMetadata metadata)
 {
     _refreshTimer.Change(_refreshTimeout, Timeout.Infinite);
 }
Пример #41
0
 public static void RevertPackagePaths(EnvDTE.Project project, IVsPackageMetadata package, string solutionDir)
 {
     RevertPackagePaths(project, new[] { package }, solutionDir);
 }
        private static Version GetNuGetPackageVersion(IVsPackageMetadata package)
        {
            Version version;
            string versionString = package.VersionString;
            int dashIndex = versionString.IndexOf('-');
            if (dashIndex != -1)
            {
                // Trim off any pre-release versions.  Because the handler should never install pre-release
                // versions they can be ignored when comparing versions.
                versionString = versionString.Substring(0, dashIndex);
            }

            if (!Version.TryParse(versionString, out version))
            {
                Debug.Fail("Unable to parse the NuGet package version " + versionString);
            }

            return version;
        }