C# NuGet.PackageDependency类代码示例

        private static PackageUpgradeAction DetectUpgradeAction(PackageDependency dependency, IPackage recentPackage)
        {
            var upgradeType = PackageUpgradeAction.None;
            if (recentPackage == null)
            {
                upgradeType = PackageUpgradeAction.Unknown;
            }
            else if (dependency.VersionSpec.Satisfies(recentPackage.Version))
            {
                upgradeType = IsMinVersionUpgradeable(dependency, recentPackage)
                        ? PackageUpgradeAction.MinVersion
                        : PackageUpgradeAction.None;
            }
            else
            {
                var fromRelease = DependsOnReleaseVersion(dependency);

                if (recentPackage.IsReleaseVersion())
                {
                    upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToRelease : PackageUpgradeAction.PrereleaseToRelease;
                }
                else
                {
                    upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToPrerelease : PackageUpgradeAction.PrereleaseToPrerelease;
                }
            }

            return upgradeType;
        }

		public void GetLinkTo_dependency_should_return_link_with_dependency_name_as_target()
		{
			var p = new TestPackage { Id = "test-package", Version = new Version("1.2.3") };
			var dependency = new PackageDependency("dep", new VersionSpec { MinVersion = new Version("1.2.3") });

			Assert.AreEqual("dep (1.2.3)", p.GetLinkTo(dependency).Target);
		}

		public void GetLinkTo_dependency_should_return_link_with_packge_category()
		{
			var p = new TestPackage { Id = "test-package", Version = new Version("1.2.3") };
			var dependency = new PackageDependency("dep", new VersionSpec { MinVersion = new Version("1.2.3") });

			Assert.AreEqual("Package", p.GetLinkTo(dependency).Category1);
		}

        private static bool IsPrereleaseDependency(PackageDependency pd)
        {
            if (pd.VersionSpec == null)
            {
                return false;
            }

            return IsPreReleasedVersion(pd.VersionSpec.MinVersion) || IsPreReleasedVersion(pd.VersionSpec.MaxVersion);
        }

 private static PackageIssue CreatePackageIssue(PackageDependency target)
 {
     return new PackageIssue(
         PackageIssueLevel.Error,
         "Invalid prerelease dependency",
         String.Format(CultureInfo.CurrentCulture,
                       "A stable release of a package must not have a dependency on a prerelease package, '{0}'.",
                       target),
         String.Format(CultureInfo.CurrentCulture,
                       "Either modify the version spec of dependency '{0}' or update the version field.", target)
         );
 }

 public void ShowDownloadStatus(PackageDependency dependentPackage)
 {
     if (uxDownloadStatus.InvokeRequired)
     {
         uxDownloadStatus.Invoke((Action)(() =>
         {
             uxDownloadStatus.Text = "Downloading the dependencies\n" + "Downloading " + dependentPackage.Id;
         }));
     }
     else
     {
         uxDownloadStatus.Text = "Downloading the dependencies\n" + "Downloading " + dependentPackage.Id;
     }
 }

 public Dependency Map(PackageDependency packageDependency, string packageId, string packageVersion)
 {
     if (packageDependency == null)
     {
         throw new ArgumentNullException("packageDependency");
     }
     string versionSpec = packageDependency.VersionSpec != null ? packageDependency.VersionSpec.ToString() : string.Empty;
     return new Dependency
     {
         Name = packageDependency.Id,
         PackageId = !string.IsNullOrWhiteSpace(packageId) ? packageId : string.Empty,
         PackageVersion = !string.IsNullOrWhiteSpace(packageVersion) ? packageVersion : string.Empty,
         VersionSpec = versionSpec
     };
 }

        public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
        {
            IDependencyResolver dependencyResolver = _repo as IDependencyResolver;
            if (dependencyResolver != null)
            {
                return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
            }

            return DependencyResolveUtility.ResolveDependencyCore(
                _repo,
                dependency,
                constraintProvider,
                allowPrereleaseVersions,
                preferListedPackages,
                dependencyVersion);
        }

        public AddInDependency(PackageDependency packageDependency)
        {
            if (packageDependency != null)
            {
                IVersionSpec versionSpec = packageDependency.VersionSpec;

                Id = packageDependency.Id;
                if (versionSpec.MinVersion != null)
                {
                    MinimumVersion = versionSpec.MinVersion.Version;
                }
                if (versionSpec.MaxVersion != null)
                {
                    MaximumVersion = versionSpec.MaxVersion.Version;
                }
                IncludeMinimumVersion = packageDependency.VersionSpec.IsMinInclusive;
                IncludeMaximumVersion = packageDependency.VersionSpec.IsMaxInclusive;
            }
        }

        public override void Context()
        {
            var minVersionSpec = new VersionSpec
            {
                MinVersion = new SemanticVersion("1.0.0"),
                IsMinInclusive = true
            };
            packageDependencyWithMinVersion = new PackageDependency("fiddler", minVersionSpec);

            var minAndMaxVersionSpec = new VersionSpec
            {
                MinVersion = new SemanticVersion("1.0.0"),
                MaxVersion = new SemanticVersion("2.0.0"),
                IsMinInclusive = true
            };
            packageDependencyWithMaxVersion = new PackageDependency("dude", minAndMaxVersionSpec);

            guideline = new DependencyWithNoVersionGuideline();
        }

 protected virtual void OnDependencyResolveError(PackageDependency dependency)
 {
 }

 private static bool DependsOnReleaseVersion(PackageDependency dependency)
 {
     return (dependency.VersionSpec.MaxVersion != null) &&
         string.IsNullOrEmpty(dependency.VersionSpec.MaxVersion.SpecialVersion) &&
         dependency.VersionSpec.IsMaxInclusive;
 }

 private static bool IsMinVersionUpgradeable(PackageDependency dependency, IPackage recentPackage)
 {
     return (dependency.VersionSpec.MinVersion != null) && (dependency.VersionSpec.MinVersion < recentPackage.Version);
 }

 protected override IPackage ResolveDependency(PackageDependency dependency)
 {
     return Repository.FindDependency(dependency);
 }

 public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
 {
     // Use the primary repository to look up dependencies. Fallback to the aggregate repository only if we can't find a package here.
     return _primaryRepository.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) ??
     _dependencyResolver.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
 }