public static IPackage Latest(this IEnumerable<IPackage> values, IVersionSpec spec)
        {
            var candidates = values.ToArray();
            var candidate = candidates.FirstOrDefault(x => x.IsAbsoluteLatestVersion)
                            ?? candidates.FirstOrDefault(x => x.IsLatestVersion);

            if (candidate == null)
            {
                // If both absolute and latest are false, then we order in descending order (by version) and take the top
                var ordered = candidates
                    .OrderByDescending(x => x.Version)
                    .ToArray();

                if (spec == null)
                {
                    candidate = ordered.FirstOrDefault();
                }
                else
                {
                    Func<IPackage, bool> predicate;
                    if (spec.IsMaxInclusive)
                    {
                        predicate = x => x.Version <= spec.MaxVersion;
                    }
                    else
                    {
                        predicate = x => x.Version < spec.MaxVersion;
                    }

                    candidate = ordered.FirstOrDefault(predicate);
                }
            }

            return candidate;
        }

        public DependencyInfo(FullPackageName fullName, IVersionSpec versionSpec)
        {
            FullName = fullName;

            // Default to the simple version (which means min-version)
            VersionSpec = versionSpec ?? VersionUtility.ParseVersionSpec(FullName.Version.ToString());
        }

        public static bool Matches(IVersionSpec versionSpec, SemanticVersion version)
        {
            if (versionSpec == null)
                return true; // I CAN'T DEAL WITH THIS

            bool minVersion;
            if (versionSpec.MinVersion == null) {
                minVersion = true; // no preconditon? LET'S DO IT
            } else if (versionSpec.IsMinInclusive) {
                minVersion = version >= versionSpec.MinVersion;
            } else {
                minVersion = version > versionSpec.MinVersion;
            }

            bool maxVersion;
            if (versionSpec.MaxVersion == null) {
                maxVersion = true; // no preconditon? LET'S DO IT
            } else if (versionSpec.IsMaxInclusive) {
                maxVersion = version <= versionSpec.MaxVersion;
            } else {
                maxVersion = version < versionSpec.MaxVersion;
            }

            return maxVersion && minVersion;
        }

        public void GetPackage(string packageId, IVersionSpec version)
        {
            /*
            if (repositoryRemote == null)
            {
                //var repositoryRemote = PackageRepositoryFactory.Default.CreateRepository("https://nuget.org/api/v2");
                repositoryRemote = PackageRepositoryFactory.Default.CreateRepository(@"C:\Dev\Tools\NuGetFeed");
            }
            if (repositoryLocal == null)
            {
                repositoryLocal = GetLocalRepository();
            }
            */
            var packageInfo = FindPackage(packageId, version, false, false);

            if (packageInfo == null)
                throw new NotImplementedException();

            var localRepository = _repositories[0];
            if (localRepository != packageInfo.Item1)
            {
                localRepository.AddPackage(packageInfo.Item2);
            }

            foreach (var deps in packageInfo.Item2.DependencySets)
            {
                foreach (var dep in deps.Dependencies)
                {
                    GetPackage(dep.Id, dep.VersionSpec);
                }
            }
        }

 public PackageDependency(string id, IVersionSpec versionSpec)
 {
     if (String.IsNullOrEmpty(id)) {
         throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "id");
     }
     Id = id;
     VersionSpec = versionSpec;
 }

 public PackageDependency(string id, IVersionSpec versionSpec)
 {
     if (String.IsNullOrEmpty(id)) {
         throw new ArgumentNullException("id");
     }
     Id = id;
     VersionSpec = versionSpec;
 }

 internal static VersionRange SafeToVerRange(IVersionSpec spec)
 {
     if(spec == null) {
         return null;
     }
     return new VersionRange(
         SafeToNuGetVer(spec.MinVersion),
         spec.IsMinInclusive,
         SafeToNuGetVer(spec.MaxVersion),
         spec.IsMaxInclusive);
 }

        public Dependency(string name, IVersionSpec versionSpec)
            : this(name)
        {
            if (versionSpec.MinVersion != null && versionSpec.MaxVersion != null &&
                versionSpec.MinVersion == versionSpec.MaxVersion)
            {
                Mode = UpdateMode.Fixed;
                Version = versionSpec.MinVersion.Version.ToString();
            }
            else
            {
                Mode = UpdateMode.Float;
            }

            _versionSpec = versionSpec;
        }

        public AzureVersionSpec(IVersionSpec version)
        {

            this.IsMaxInclusive = version.IsMaxInclusive;
            this.IsMinInclusive = version.IsMinInclusive;

            if (version.MaxVersion != null)
            {
                this.MaxVersionSpecial = version.MaxVersion.SpecialVersion;
                this.MaxVersionVersion = version.MaxVersion.Version.ToString();
            }

            if (version.MinVersion != null)
            {
                this.MinVersionSpecial = version.MinVersion.SpecialVersion;
                this.MinVersionVersion = version.MinVersion.Version.ToString();
            }
        }

        /// <summary>
        /// Enumerates the required package requests.
        /// </summary>
        /// <param name="packageId">
        /// The package id.
        /// </param>
        /// <param name="version">
        /// The version.
        /// </param>
        /// <returns>
        /// An enumeration of package requests.
        /// </returns>
        public IEnumerable<SolutionPackageRequest> EnumPackageRequests(string packageId, IVersionSpec version)
        {
            if (packageId.EndsWith(Constants.SolutionPackagePostFix, StringComparison.CurrentCultureIgnoreCase))
            {
                var packageRequest = SolutionPackageRequestFactory.CreatePackageRequest(packageId, version);
                if (packageRequest != null)
                {
                    yield return packageRequest;

                    foreach (var dependencySet in packageRequest.Package.DependencySets)
                    {
                        foreach (var dependency in dependencySet.Dependencies)
                        {
                            foreach (var request in this.EnumPackageRequests(dependency.Id, dependency.VersionSpec))
                            {
                                yield return request;
                            }
                        }
                    }
                }
            }
        }

        IPackage findPackageFromName(string id, IVersionSpec versionSpec, string packagesRootDir = null, IQueryable<IPackage> machineCache = null)
        {
            machineCache = machineCache ?? Enumerable.Empty<IPackage>().AsQueryable();

            if (packagesRootDir != null && localPackageCache == null) {
                localPackageCache = Utility.GetAllFilePathsRecursively(packagesRootDir)
                    .Where(PackageHelper.IsPackageFile)
                    .Select(x => new ZipPackage(x))
                    .ToArray();
            }

            return findPackageFromNameInList(id, versionSpec, localPackageCache ?? Enumerable.Empty<IPackage>()) ??
                findPackageFromNameInList(id, versionSpec, machineCache);
        }

 static IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IEnumerable<IPackage> packageList)
 {
     return packageList.Where(x => x.Id == id).ToArray()
         .FirstOrDefault(x => VersionComparer.Matches(versionSpec, x.Version));
 }

 public NuspecDependency(string name, IVersionSpec spec)
 {
     Name = name;
     VersionSpec = spec;
 }

		public void UpdatePackageReference (string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
		{
			throw new NotImplementedException ();
		}

 public void AddConstraint(string packageId, IVersionSpec versionSpec)
 {
     _constraints[packageId] = versionSpec;
 }

        /// <summary>
        /// Copyright 2010 Outercurve Foundation 
        /// Licensed under the Apache License, Version 2.0 (the "License"); 
        /// you may not use this file except in compliance with the License. 
        /// You may obtain a copy of the License at 
        ///  http://www.apache.org/licenses/LICENSE-2.0 
        /// Unless required by applicable law or agreed to in writing, software 
        /// distributed under the License is distributed on an "AS IS" BASIS, 
        /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
        /// See the License for the specific language governing permissions and 
        /// limitations under the License.
        /// </summary>
        /// <param name="value"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool TryParseVersionSpec(string value, out IVersionSpec result)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            var versionSpec = new VersionSpec();
            value = value.Trim();

            // First, try to parse it as a plain version string
            Version version;
            if (Version.TryParse(value, out version))
            {
                // A plain version is treated as an inclusive minimum range
                result = new VersionSpec
                {
                    MinVersion = version,
                    IsMinInclusive = true
                };

                return true;
            }

            // It's not a plain version, so it must be using the bracket arithmetic range syntax

            result = null;

            // Fail early if the string is too short to be valid
            if (value.Length < 3)
            {
                return false;
            }

            // The first character must be [ ot (
            switch (value.First())
            {
                case '[':
                    versionSpec.IsMinInclusive = true;
                    break;
                case '(':
                    versionSpec.IsMinInclusive = false;
                    break;
                default:
                    return false;
            }

            // The last character must be ] ot )
            switch (value.Last())
            {
                case ']':
                    versionSpec.IsMaxInclusive = true;
                    break;
                case ')':
                    versionSpec.IsMaxInclusive = false;
                    break;
                default:
                    return false;
            }

            // Get rid of the two brackets
            value = value.Substring(1, value.Length - 2);

            // Split by comma, and make sure we don't get more than two pieces
            string[] parts = value.Split(',');
            if (parts.Length > 2)
            {
                return false;
            }

            // If there is only one piece, we use it for both min and max
            string minVersionString = parts[0];
            string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0];

            // Only parse the min version if it's non-empty
            if (!String.IsNullOrWhiteSpace(minVersionString))
            {
                if (!Version.TryParse(minVersionString, out version))
                {
                    return false;
                }
                versionSpec.MinVersion = version;
            }

            // Same deal for max
//.........这里部分代码省略.........

    private static IVersionSpec StripPatchLevel(IVersionSpec dependencyVersionSpec)
    {
      // Given a curatedFeedVersion of 8.0, make [8.0.1] work. Semver says the patch
      // level should be backwards compatible, so this should be safe
      var spec = new VersionSpec
      {
        IsMinInclusive = true,
        MinVersion =
          new SemanticVersion(dependencyVersionSpec.MinVersion.Version.Major,
            dependencyVersionSpec.MinVersion.Version.Minor, 0, 0),
        IsMaxInclusive = dependencyVersionSpec.IsMaxInclusive,
        MaxVersion = dependencyVersionSpec.MaxVersion
      };

      return spec;
    }

        IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IQueryable<IPackage> packageList)
        {
            // Apply a VersionSpec to a specific Version (this code is nicked
            // from NuGet)
            return packageList.Where(x => x.Id == id).ToArray().FirstOrDefault(x => {
                if (((versionSpec != null) && (versionSpec.MinVersion != null)) && (versionSpec.MaxVersion != null)) {
                    if ((!versionSpec.IsMaxInclusive || !versionSpec.IsMinInclusive) && (versionSpec.MaxVersion == versionSpec.MinVersion)) {
                        return false;
                    }

                    if (versionSpec.MaxVersion < versionSpec.MinVersion) {
                        return false;
                    }
                }

                return true;
            });
        }

 public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 {
     UpdatePackage(packageId, () => SourceRepository.FindPackage(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted: false),
         updateDependencies, allowPrereleaseVersions);
 }

        /// <summary>
        /// Adds a package that has been resolved as the latest within a constraint.  Saves doing the math and resolution again.
        /// </summary>
        /// <param name="package"></param>
        /// <param name="constraint"></param>
        /// <returns></returns>
        public bool AddCacheEntryByConstraint(IPackage package, IVersionSpec constraint)
        {
            if (!_latestPackageConstraintCache.ContainsKey(package.Id))
                _latestPackageConstraintCache.Add(package.Id, new Dictionary<IVersionSpec, IPackage>());

            if (!_latestPackageConstraintCache[package.Id].ContainsKey(constraint))
            {
                _latestPackageConstraintCache[package.Id].Add(constraint, package);
                return true;
            }
            return false;

        }