Exemplo n.º 1
0
        public override bool Execute()
        {
            Func <string, bool> isKnownPackage;

            if (PackageIndexes != null && PackageIndexes.Length > 0)
            {
                var index = PackageIndex.Load(PackageIndexes.Select(pi => pi.GetMetadata("FullPath")));
                isKnownPackage = packageId => index.Packages.ContainsKey(packageId);
            }
            else
            {
                var baseLinePackageIds = new HashSet <string>(BaseLinePackages.NullAsEmpty().Select(b => b.ItemSpec));
                isKnownPackage = packageId => baseLinePackageIds.Contains(packageId);
            }

            FilteredDependencies = OriginalDependencies.Where(
                dependency =>
                !dependency.ItemSpec.StartsWith("System.Private") ||      // only apply filtering to System.Private dependencies
                isKnownPackage(dependency.ItemSpec)
                ).ToArray();

            return(!Log.HasLoggedErrors);
        }
        public override bool Execute()
        {
            var dependencies = OriginalDependencies.Select(od => new Dependency(od)).ToArray();

            // preserve all of the TFM-specific dependencies that are not NETStandard.
            List <ITaskItem> splitDependencies = new List <ITaskItem>(dependencies.Where(d => d.TargetFramework != null && d.TargetFramework.Framework != FrameworkConstants.FrameworkIdentifiers.NetStandard).Select(d => d.OriginalItem));

            // for any dependency with unspecified TFM, get its minimum supported netstandard version
            // and treat it as targeting that.
            var unspecDeps = dependencies.Where(d => d.TargetFramework == null).ToArray();

            foreach (var unspecDep in unspecDeps)
            {
                unspecDep.TargetFramework = unspecDep.MinimumNETStandard;
            }

            // get all distinct netstandard TFMs
            var netStandardGroups = dependencies.Select(d => d.TargetFramework)
                                    .Where(fx => fx != null && fx.Framework == FrameworkConstants.FrameworkIdentifiers.NetStandard)
                                    .Distinct()
                                    .OrderBy(fx => fx.Version)
                                    .ToArray();

            // for every netstandard group include all dependencies that support that version of NETStandard or lower
            foreach (var netStandardGroup in netStandardGroups)
            {
                var applicableDependencies = dependencies.Where(d => d.TargetFramework != null &&
                                                                d.TargetFramework.Framework == FrameworkConstants.FrameworkIdentifiers.NetStandard &&
                                                                d.TargetFramework.Version <= netStandardGroup.Version);
                splitDependencies.AddRange(applicableDependencies.Select(d => d.GetItemWithTargetFramework(netStandardGroup)));
            }

            SplitDependencies = splitDependencies.ToArray();

            return(!Log.HasLoggedErrors);
        }