Version

NuGet\Commands\SearchCommand.cs (1)

267Version = result.Identity.Version.ToString(),

NugetPackageDownloader\NuGetPackageDownloader.cs (9)

398packageVersion = packageMetadata.Identity.Version; 665var availableVersions = accumulativeSearchResults.Select(t => t.package.Identity.Version).ToList(); 669var bestResult = accumulativeSearchResults.First(t => t.package.Identity.Version == bestVersion); 770.Where(r => !r.package.Identity.Version.IsPrerelease); 774var results = stableVersions.OrderByDescending(r => r.package.Identity.Version); 780.OrderByDescending(r => r.package.Identity.Version); 809return (packageMetadata.Identity.Version, source); 844package.Identity.Version == packageVersion); 947result.Item2.Identity.Version);

NuGetUtility.cs (1)

62Version threePartVersion = VersionUtility.As3PartVersion(packageMetadata.Identity.Version.Version);

UpdatePackageIndex.cs (1)

237version = identity.Version;

WorkloadPackageBase.cs (3)

132public NuGetVersion PackageVersion => Identity.Version; 168public Version Version => Identity.Version.Version; 208SwixPackageId = $"{Id.Replace(shortNames)}.{Identity.Version}";

src\ReadNuGetPackageInfos.cs (1)

37["PackageVersion"] = identity.Version.OriginalVersion

src\UsageReport\Usage.cs (2)

78PackageIdentity.Version); 85$"{PackageIdentity.Id} {PackageIdentity.Version} " +

src\UsageReport\WritePackageUsageData.cs (2)

209.Where(id => properties.Contains(id.Id + "/" + id.Version.OriginalVersion))) 214d.version.Satisfies(identity.Version));

src\UsageReport\WriteUsageReports.cs (1)

113string version = usage.PackageIdentity.Version.OriginalVersion;

src\UsageReport\XmlParsingHelpers.cs (1)

18new XAttribute("Version", ident.Version.OriginalVersion));

src\WriteBuildOutputProps.cs (3)

63.Select(g => g.OrderBy(id => id.Version).Last()) 86sw.WriteLine($" <{propertyName}>{packageIdentity.Version}</{propertyName}>"); 89sw.WriteLine($" <{propertyName}>{packageIdentity.Version}</{propertyName}>");

DependencyContextBuilder.cs (1)

921_dependencyLibraries[packageToFilter.Id].Version == packageToFilter.Version)

FilterResolvedFiles.cs (1)

92item.SetMetadata("Version", resolvedPkg.Version.ToString());

ParseTargetManifests.cs (1)

52string packageVersion = storeEntry.Key.Version.ToNormalizedString();

ProjectContext.cs (1)

298if (dependency.Version.Equals(library.Version))

RemoveDuplicatePackageReferences.cs (1)

48item.SetMetadata("Version", pkg.Version.ToString());

ResolvedFile.cs (1)

54PackageVersion = package.Version.ToString();

NuGet\NugetApiManager.cs (5)

59matchedPackage = packagesMetadata.FirstOrDefault(pm => pm.Identity.Version == new NuGetVersion(packageVersion)); 68!(current.Identity.Version > max!.Identity.Version)) 69|| !floatRange.Satisfies(current.Identity.Version)) 126PackageVersion = metadata.Identity.Version;

TemplatePackageCoordinator.cs (3)

935(max == null || current!.Identity.Version > max.Identity.Version) 937floatRange.Satisfies(current!.Identity.Version) ?

Installers\NuGet\NugetApiPackageManager.cs (17)

_generated\7\PackageSearchJsonContext.PackageIdentity.g.cs (2)

79Getter = static obj => ((global::NuGet.Packaging.Core.PackageIdentity)obj).Version, 130NuGetVersionSerializeHandler(writer, ((global::NuGet.Packaging.Core.PackageIdentity)value).Version);

Commands\Package\Download\PackageDownloadRunner.cs (2)

215if (package?.Identity?.Version == packageWithNuGetVersion.NuGetVersion) 226var version = package.Identity.Version;

Commands\Package\Update\PackageUpdateCommandRunner.cs (2)

198var nonVulnerableVersion = await packageUpdateIO.GetNonVulnerableAsync(packageIdentity.Id, mappedSources, packageIdentity.Version, NullLogger.Instance, knownVulnerabilities, cancellationToken); 210CurrentVersion = new VersionRange(packageIdentity.Version),

Commands\Package\Update\PackageUpdateIO.cs (4)

396.Where(p => p.Version >= minVersion && !PackageHasKnownVulnerability(p)) 397.Select(p => p.Version); 412if (vulnerability.Versions.Satisfies(package.Version)) 445NuGetVersion highestVersion = packageDetails.Max(p => p.Identity.Version)!;

Commands\PackageReferenceCommands\ListPackage\ListPackageCommandRunner.cs (19)

Commands\PackageSearch\JsonFormat\SearchResultPackagesConverter.cs (1)

43var version = value.Identity.Version?.ToNormalizedString();

Commands\PackageSearch\PackageSearchResultTableRenderer.cs (1)

85string version = result.Identity.Version.ToNormalizedString();

Utility\AddPackageCommandUtility.cs (1)

87return packages?.Max(x => x.Identity.Version);

Utility\ListPackageHelper.cs (4)

17|| p.ResolvedPackageMetadata.Identity.Version < p.LatestPackageMetadata.Identity.Version); 20|| p.ResolvedPackageMetadata.Identity.Version < p.LatestPackageMetadata.Identity.Version;

Utility\ProjectPackagesPrintUtility.cs (2)

257package.LatestPackageMetadata?.Identity?.Version?.ToString() : 258package.ResolvedPackageMetadata?.Identity?.Version?.ToString();

ListCommand\ListCommandRunner.cs (2)

171listArgs.PrintJustified(1, p.Identity.Version.ToFullString()); 194listArgs.PrintJustified(0, p.Identity.Id + " " + p.Identity.Version.ToFullString());

RestoreCommand\CompatibilityIssue.cs (7)

132return string.Format(CultureInfo.CurrentCulture, Strings.Log_MissingImplementationFx, Package.Id, Package.Version, AssemblyName, Framework); 134return string.Format(CultureInfo.CurrentCulture, Strings.Log_MissingImplementationFxRuntime, Package.Id, Package.Version, AssemblyName, Framework, RuntimeIdentifier); 141Package.Version.ToNormalizedString(), 147Package.Version.ToNormalizedString()); 152Package.Version.ToNormalizedString()); 178Package.Version.ToNormalizedString()); 187Package.Version.ToNormalizedString(),

RestoreCommand\OriginalCaseGlobalPackageFolder.cs (1)

81var hashPath = _pathResolver.GetNupkgMetadataPath(identity.Id, identity.Version);

RestoreCommand\ProjectRestoreCommand.cs (2)

401if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version)) 427if (installed || !userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version))

RestoreCommand\SourceRepositoryDependencyProvider.cs (1)

408packageInfo.PackageIdentity.Version,

RestoreCommand\Utility\AuditUtility.cs (1)

284package.Version.ToNormalizedString(),

RestoreCommand\Utility\BuildAssetsUtils.cs (2)

530if (sortedPkg.Id.Equals(assetsPkg.Name, StringComparison.OrdinalIgnoreCase) && sortedPkg.Version == assetsPkg.Version) 536sortedPkg.Version));

Audit\AuditChecker.cs (2)

260package.Version.ToNormalizedString(), 324List<PackageVulnerabilityInfo>? knownVulnerabilitiesForPackage = GetKnownVulnerabilities(packageIdentity.Id, packageIdentity.Version, knownVulnerabilities);

Audit\AuditCheckResult.cs (1)

91packageData["version"] = package.Version;

BuildIntegration\BuildIntegratedRestoreUtility.cs (3)

45var packageInstallPath = pathResolver.GetPackageDirectory(package.Id, package.Version); 155var info = pathResolver.GetPackageInfo(package.Id, package.Version); 163var nuspecFilePath = info.PathResolver.GetManifestFilePath(package.Id, package.Version);

InstallationCompatibility.cs (3)

66identity.Version); 72identity.Version); 153var identityString = $"{packageIdentity.Id} {packageIdentity.Version.ToNormalizedString()}";

NuGetPackageManager.cs (29)

PackageDownloader.cs (1)

210packageIdentity.Version.ToNormalizedString()));

PackagePreFetcher.cs (2)

194fetchResult.Package.Version.ToNormalizedString(), 204fetchResult.Package.Version.ToNormalizedString(),

Projects\MSBuildNuGetProject.cs (1)

268Strings.UnableToFindCompatibleItems, packageIdentity.Id + " " + packageIdentity.Version.ToNormalizedString(), ProjectSystem.TargetFramework));

Resolution\GatherExceptionHelpers.cs (3)

60if (packagesForId.Any() && !packagesForId.Any(package => configEntry.AllowedVersions.Satisfies(package.Version))) 87if (configEntry != null && availablePackage != null && configEntry.PackageIdentity.Version > availablePackage.Version)

Resolution\PrunePackageTree.cs (21)

25var allowedPackageIdentity = new HashSet<PackageIdentity>(installedPackages.Where(p => p.HasVersion && p.Version.IsPrerelease), PackageIdentityComparer.Default); 33return packages.Where(p => !(p.HasVersion && p.Version.IsPrerelease) || allowedPackageId.Contains(p.Id)); 39return packages.Where(p => !(p.HasVersion && p.Version.IsPrerelease) || allowedPackageIdentity.Contains(p)); 53return packages.Where(p => !(p.HasVersion && p.Version.IsPrerelease) || allowed.Contains(p.Id)); 58foreach (var p in targets.Where(p => p.HasVersion && p.Version.IsPrerelease)) 66var prereleasePackageToInstall = new HashSet<PackageIdentity>(packagesToInstall.Where(p => p.HasVersion && p.Version.IsPrerelease), PackageIdentityComparer.Default); 110installed.Add(packageReference.PackageIdentity.Id, packageReference.PackageIdentity.Version); 118return version <= package.Version; 144(StringComparer.OrdinalIgnoreCase.Equals(target.Id, p.Id) && comparer.Equals(p.Version, target.Version))); 153(StringComparer.OrdinalIgnoreCase.Equals(id, p.Id) && !p.Version.IsPrerelease)); 164(StringComparer.OrdinalIgnoreCase.Equals(minimum.Id, p.Id) && comparer.Compare(p.Version, minimum.Version) >= 0)); 173|| packageReference.AllowedVersions.Satisfies(p.Version)); 186targets.Add(primaryTarget.Id, primaryTarget.Version); 189return packages.Where(p => !targets.ContainsKey(p.Id) || (targets.ContainsKey(p.Id) && targets[p.Id] == p.Version)); 199if (highest == null || highest.Version < package.Version) 221installed[packageReference.PackageIdentity.Id] = packageReference.PackageIdentity.Version; 224return packages.Where(p => !installed.ContainsKey(p.Id) || MeetsVersionConstraints(p.Version, installed[p.Id], versionConstraints)); 229return packages.Where(p => MeetsVersionConstraints(p.Version, existingVersion, versionConstraints));

Resolution\ResolverGather.cs (4)

156&& package.Version < installedPackage.Version); 224packageIdentity = string.Format(CultureInfo.CurrentCulture, "{0} {1}", targetId, pid.Version); 432request.Package.Version,

Resolution\UninstallResolver.cs (2)

23var packageIdentity = new PackageIdentity(dependencyInfo.Id, dependencyInfo.Version); 28&& dependency.VersionRange.Satisfies(i.Version));

Utility\JsonConfigUtility.cs (2)

77if (package.Version != null) 80minVersion: package.Version,

Utility\PackageGraphAnalysisUtilities.cs (1)

85if (packageDependencyInfo.Dependencies.Any(d => package.Id == d.Id && package.Version == d.VersionRange.MinVersion))

Utility\PackagesConfigLockFileUtility.cs (6)

272RequestedVersion = new VersionRange(toInstall.PackageIdentity.Version, includeMinVersion: true, toInstall.PackageIdentity.Version, includeMaxVersion: true), 273ResolvedVersion = toInstall.PackageIdentity.Version, 324RequestedVersion = new VersionRange(package.PackageIdentity.Version, includeMinVersion: true, package.PackageIdentity.Version, includeMaxVersion: true), 325ResolvedVersion = package.PackageIdentity.Version,

Core\comparers\PackageIdentityComparer.cs (5)

83return _versionComparer.Equals(x.Version!, y.Version!) 100combiner.AddObject(obj.Version, _versionComparer); 129result = _versionComparer.Compare(x.Version!, y.Version!);

Core\PackageDependencyInfo.cs (1)

32: this(identity.Id, identity.Version, dependencies)

Core\PackageIdentity.cs (1)

123? String.Format(CultureInfo.InvariantCulture, ToStringFormat, Id, Version!.ToNormalizedString())

MinClientVersionUtility.cs (1)

37packageIdentity.Id + " " + packageIdentity.Version.ToNormalizedString(),

PackageExtraction\PackagePathHelper.cs (4)

101parsedVersion.Equals(packageIdentity.Version); 111if (packageIdentity.Version == null) 114string.Format(CultureInfo.CurrentCulture, Strings.PropertyCannotBeNull, nameof(packageIdentity.Version)), 124var version = packageIdentity.Version;

PackageExtractor.cs (21)

PackagePathResolver.cs (1)

109return identity.Version.ToString();

PackagesConfigWriter.cs (4)

238Strings.PackageEntryNotExist, oldEntry.PackageIdentity.Id, oldEntry.PackageIdentity.Version)); 353Strings.PackageEntryNotExist, entry.PackageIdentity.Id, entry.PackageIdentity.Version)); 366node.Add(new XAttribute(XName.Get(PackagesConfig.VersionAttributeName), entry.PackageIdentity.Version)); 437if (isNuGetVersion && nuGetVersion != null && nuGetVersion.Equals(entry.PackageIdentity.Version))

Rules\PathTooLongRule.cs (1)

22var installedPath = versionFolderPathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);

Telemetry\PackageExtractionTelemetryEvent.cs (1)

46AddPiiData(nameof(PackageVersion), packageId.Version!.ToNormalizedString().ToLowerInvariant());

PackageSpecOperations.cs (3)

97AddOrUpdateDependency(spec, new PackageDependency(identity.Id, new VersionRange(identity.Version))); 206AddOrUpdateDependency(spec, new PackageDependency(identity.Id, new VersionRange(identity.Version)), frameworksToAdd); 224AddOrUpdateDependency(spec, new PackageDependency(identity.Id, new VersionRange(identity.Version)), frameworksToAdd);

DependencyInfo\ResolverMetadataClient.cs (1)

147Version = item.Identity.Version,

HttpSource\HttpStreamValidation.cs (2)

133expectedIdentity.Version, 135actualIdentity.Version);

LegacyFeed\DependencyInfoResourceV2Feed.cs (1)

104var identity = new PackageIdentity(packageVersion.Id, NuGetVersion.Parse(packageVersion.Version.ToString()));

LegacyFeed\MetadataResourceV2Feed.cs (1)

78return packages.Select(p => p.Version).ToArray();

LegacyFeed\PackageMetadataResourceV2Feed.cs (1)

69var filter = new SearchFilter(v2Package.Version.IsPrerelease);

LegacyFeed\PackageSearchResourceV2Feed.cs (1)

57.Select(group => group.OrderByDescending(p => p.Version).First())

LegacyFeed\V2FeedListResource.cs (4)

201.Select(group => group.OrderByDescending(p => p.Version)).SelectMany(pg => pg) 208.Select(group => group.OrderByDescending(p => p.Version).First()) 234.Select(group => group.OrderByDescending(p => p.Version)).SelectMany(pg => pg) 241.Select(group => group.OrderByDescending(p => p.Version).First())

LegacyFeed\V2FeedPackageInfo.cs (1)

50: base(identity.Id, identity.Version)

LegacyFeed\V2FeedParser.cs (4)

140.FirstOrDefault(p => p.Version == package.Version); 181.Where(p => (includeUnlisted || p.IsListed) && (includePrerelease || !p.Version.IsPrerelease)); 183return filtered.OrderByDescending(p => p.Version).Distinct().ToList();

LegacyFeed\V2FeedQueryBuilder.cs (2)

119throw new ArgumentException(nameof(package.Version)); 128UriUtility.UrlEncodeOdataParameter(package.Version.ToNormalizedString()));

LegacyFeed\V2FeedUtilities.cs (3)

58foreach (var versionPackage in packages.OrderByDescending(p => p.Version)) 60if (uniqueVersions.Add(versionPackage.Version)) 62var versionInfo = new VersionInfo(versionPackage.Version, versionPackage.DownloadCount)

LocalRepositories\LocalAutoCompleteResource.cs (5)

80packages = packages.Where(p => !p.Identity.Version.IsPrerelease); 106packages = packages.Where(p => !p.Identity.Version.IsPrerelease); 110return packages.Where(p => p.Identity.Version.ToString() 112|| p.Identity.Version.ToFullString().StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase)) 113.Select(p => p.Identity.Version)

LocalRepositories\LocalMetadataResource.cs (1)

89.Select(p => p.Identity.Version)

LocalRepositories\LocalPackageMetadataResource.cs (1)

44.Where(p => includePrerelease || !p.Identity.Version.IsPrerelease)

LocalRepositories\LocalPackageSearchResource.cs (7)

55query = query.Where(package => filters.IncludePrerelease || !package.Identity.Version.IsPrerelease); 136.Where(v => filter.IncludePrerelease || !v.Identity.Version.IsPrerelease) 137.Select(p => new VersionInfo(p.Identity.Version, downloadCount: 0)) 142if (!versions.Any(v => v.Version == package.Identity.Version)) 144var packageVersionInfo = new VersionInfo(package.Identity.Version, downloadCount: 0) 197&& VersionComparer.VersionRelease.Compare(maxElement.Identity.Version, element.Identity.Version) < 0))

LocalRepositories\LocalV2FindPackageByIdResource.cs (3)

101return Task.FromResult(infos.Select(p => p.Identity.Version)); 275.FirstOrDefault(package => package.Identity.Version == version); 318var packageInfo = GetPackageInfo(packageIdentity.Id, packageIdentity.Version, cacheContext, logger);

LocalRepositories\LocalV3FindPackageByIdResource.cs (3)

360if (DoesVersionExist(packageIdentity.Id, packageIdentity.Version)) 362var packagePath = _resolver.GetPackageFilePath(packageIdentity.Id, packageIdentity.Version); 363var matchedPackageIdentity = new PackageIdentity(packageIdentity.Id, packageIdentity.Version);

Model\PackageSearchMetadataV2Feed.cs (2)

37Version = package.Version; 66Version = package.Version;

Plugins\PluginPackageDownloader.cs (1)

199_packageIdentity.Version.ToNormalizedString(),

Plugins\PluginPackageReader.cs (4)

279var packageVersion = _packageIdentity.Version.ToNormalizedString(); 928var packageVersion = _packageIdentity.Version.ToNormalizedString(); 1024var packageVersion = _packageIdentity.Version.ToNormalizedString(); 1070var packageVersion = _packageIdentity.Version.ToNormalizedString();

RemotePackageArchiveDownloader.cs (1)

181_packageIdentity.Version,

RemoteRepositories\HttpFileSystemBasedFindPackageByIdResource.cs (1)

354if (packageVersions == null || !packageVersions.Contains(packageIdentity.Version))

RemoteRepositories\PluginFindPackageByIdResource.cs (3)

288packageInfo.Identity.Version.ToNormalizedString()), 467if (!results.ContainsKey(packageInfo.Identity.Version)) 469results.Add(packageInfo.Identity.Version, packageInfo);

RemoteRepositories\RemoteV2FindPackageByIdResource.cs (3)

125return result.Select(item => item.Identity.Version); 340packageIdentity.Version, 436return packageInfos.FirstOrDefault(p => p.Identity.Version == version);

RemoteRepositories\RemoteV3FindPackageByIdResource.cs (3)

116return result.Select(item => item.Identity.Version); 330packageIdentity.Version, 426return packageInfos.FirstOrDefault(p => p.Identity.Version == version);

Resources\DependencyInfoResourceV3.cs (2)

75var singleVersion = new VersionRange(minVersion: package.Version, includeMinVersion: true, maxVersion: package.Version, includeMaxVersion: true);

Resources\DownloadResourcePlugin.cs (2)

119new PrefetchPackageRequest(_packageSource.Source, identity.Id, identity.Version.ToNormalizedString()), 141$"{identity.Id}.{identity.Version.ToNormalizedString()}"));

Resources\DownloadResourceV3.cs (1)

89var version = identity.Version.ToNormalizedString().ToLowerInvariant();

Resources\PackageMetadataResourceV3.cs (2)

85var range = new VersionRange(package.Version, includeMinVersion: true, package.Version, includeMaxVersion: true);

Resources\PackageUpdateResource.cs (1)

921string.Format(CultureInfo.InvariantCulture, TempApiKeyServiceEndpoint, packageIdentity.Id, packageIdentity.Version), noServiceEndpoint);

Resources\RegistrationResourceV3.cs (4)

89|| package.Version == null) 97package.Id.ToLowerInvariant(), package.Version.ToNormalizedString().ToLowerInvariant())); 106return (await GetPackageMetadata(identity.Id, new VersionRange(identity.Version, true, identity.Version, true), true, true, cacheContext, log, token)).SingleOrDefault();

Utility\FindPackagesByIdNupkgDownloader.cs (1)

272"nupkg_" + identity.Id.ToLowerInvariant() + "." + identity.Version.ToNormalizedString(),

Utility\GlobalPackagesFolderUtility.cs (4)

37var nupkgMetadataPath = defaultPackagePathResolver.GetNupkgMetadataPath(packageIdentity.Id, packageIdentity.Version); 38var hashPath = defaultPackagePathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version); 41packageIdentity.Version); 44packageIdentity.Version);

Utility\LocalFolderUtility.cs (8)

218identity.Version.ToString(), 219package.Identity.Version.ToString())) 370var idVersion = $"{identity.Id}.{identity.Version.ToString()}"; 397if (identity.Version == dirVersion) 666var nupkgPath = pathResolver.GetPackageFilePath(identity.Id, identity.Version); 667var nuspecPath = pathResolver.GetManifestFilePath(identity.Id, identity.Version); 668var hashPath = pathResolver.GetHashPath(identity.Id, identity.Version); 691new PackageIdentity(identity.Id, identity.Version),

Utility\OfflineFeedUtility.cs (4)

36var nupkgFilePath = versionFolderPathResolver.GetPackageFilePath(packageIdentity.Id, packageIdentity.Version); 37var hashFilePath = versionFolderPathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version); 38var nuspecFilePath = versionFolderPathResolver.GetManifestFilePath(packageIdentity.Id, packageIdentity.Version); 74versionFolderPathResolver.GetPackageFilePath(packageIdentity.Id, packageIdentity.Version));

PackageResolver.cs (9)

58p.Version.Equals(package.Version)); 78VersionComparer.Default.Compare(p.Version, package.Version) > 0); 82var packageString = $"'{package.Id} {package.Version.ToNormalizedString()}'"; 115resolverPackages.Add(new ResolverPackage(package.Id, package.Version, dependencies, package.Listed, false)); 199String.Join(" => ", circularReferences.Select(package => $"{package.Id} {package.Version.ToNormalizedString()}")))); 236return $"'{package.Id} {package.Version.ToNormalizedString()} {Strings.DependencyConstraint}: {dependencyString}'"; 298package => dependencyByPackageId[package.Id].Satisfies(package.Version) || mustKeep.Contains(package.Id))

ResolverComparer.cs (10)

40if (package.Version != null) 42_installedVersions.Add(package.Id, package.Version); 100var xv = x.Version; 101var yv = y.Version; 166return new[] { x, y }.OrderBy(p => p.Version.Major) 167.ThenByDescending(p => p.Version.Minor) 168.ThenByDescending(p => p.Version.Patch).FirstOrDefault() == x ? -1 : 1; 178return new[] { x, y }.OrderBy(p => p.Version.Major) 179.ThenBy(p => p.Version.Minor) 180.ThenByDescending(p => p.Version.Patch).FirstOrDefault() == x ? -1 : 1;

ResolverPackage.cs (2)

74: this(info.Id, info.Version, info.Dependencies, listed, absent) 101return String.Format(CultureInfo.InvariantCulture, "{0} {1}", Id, Version);

ResolverUtility.cs (9)

150package.Version != null && StringComparer.OrdinalIgnoreCase.Equals(package.Id, problemPackageId)); 158problemPackageId, packageOptions.First().Version.ToNormalizedString()); 197return $"'{package.Id} {package.Version.ToNormalizedString()} {Strings.DependencyConstraint}: {dependencyString}'"; 262&& (dependency.VersionRange == null || dependency.VersionRange.Satisfies(package.Version)); 267return package != null && (dependency.VersionRange == null || dependency.VersionRange.Satisfies(package.Version)); 279|| targetPackage.Version == null || !range.Satisfies(targetPackage.Version))) 379return p2.Absent || !p1ToP2Dependency.Satisfies(p2.Version); 385return p1.Absent || !p2ToP1Dependency.Satisfies(p1.Version);