private async Task GetPackageDependencies(string registrationBaseUrl, string packageId, NuGetVersion version, NuGetFramework targetFramework, ConcurrentDictionary <PackageDependencyInfo, string> packages)
        {
            var package = await GetRegistrationLeaf(registrationBaseUrl, packageId, version);

            var packageIdentity = new PackageDependencyInfo
            {
                Id      = package.CatalogEntry.PackageId,
                Version = package.CatalogEntry.Version
            };

            if (!packages.TryAdd(packageIdentity, package.PackageContent))
            {
                return;
            }
            Console.WriteLine($"Fetched {package.PackageContent}");

            try
            {
                if (package.CatalogEntry.DependencyGroups == null)
                {
                    return;
                }
                var reducer    = new FrameworkReducer();
                var frameworks = package.CatalogEntry.DependencyGroups.Select(x => x.TargetFramework);
                var nearest    = reducer.GetNearest(targetFramework, frameworks);
                var neareastDependencyGroup = package.CatalogEntry.DependencyGroups
                                              .First(x => nearest.Equals(x.TargetFramework));

                if (neareastDependencyGroup.Dependencies != null)
                {
                    await Task.WhenAll(neareastDependencyGroup.Dependencies.Select(x =>
                    {
                        var dependency = new PackageIdentity
                        {
                            Id      = x.Id,
                            Version = x.Range.MinVersion
                        };
                        packageIdentity.Dependencies.Add(dependency);
                        return(GetPackageDependencies(registrationBaseUrl, dependency.Id, dependency.Version, targetFramework, packages));
                    }));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        private static IEnumerable <PackageIdentity> PrunePackages(PackageDependencyInfo target, ISet <PackageDependencyInfo> availablePackages)
        {
            // Get all duplicate Ids. Sort by version and remove all but highest.
            var packagesToRemove = new HashSet <PackageIdentity>(availablePackages
                                                                 .GroupBy(x => x.Id)
                                                                 .Where(x => x.Count() > 1)
                                                                 .SelectMany(x => x.OrderByDescending(p => p.Version, VersionComparer.Default).Skip(1)),
                                                                 PackageIdentityComparer.Default);

            packagesToRemove.Add(new PackageDependencyInfo
            {
                Id      = "NETStandard.Library",
                Version = new NuGetVersion(1, 6, 1)
            });

            var packagesSet = new HashSet <PackageIdentity>(PackageIdentityComparer.Default);

            PrunePackages(target, availablePackages, packagesToRemove, packagesSet);

            return(packagesSet);
        }