C# IPackage.HasProjectContent方法代码示例

        public override void AddPackage(IPackage package)
        {
            base.AddPackage(package);

            if (!package.HasProjectContent())
            {
                AddPackageReferenceEntry(package.Id, package.Version);
            }
        }

        public override void RemovePackage(IPackage package)
        {
            base.RemovePackage(package);

            if (package.HasProjectContent())
            {
                _references.Remove(package.Id);
            }
            else
            {
                _solutionReferences.Remove(package.Id);
            }
        }

        public override void AddPackage(IPackage package)
        {
            base.AddPackage(package);

            if (package.HasProjectContent())
            {
                _references[package.Id] = package.Version;
            }
            else
            {
                _solutionReferences[package.Id] = package.Version;
            }
        }

        private bool IsSolutionLevel(IPackage package)
        {
            // A package is solution level if 
            // - it doesn't have project content & 
            // - it doesn't have dependency on non solution-level package &
            // - it is not referenced by any project.
            if (package.HasProjectContent())
            {
                return false;
            }

            if (HasProjectLevelPackageDependency(package))
            {
                return false;
            }

            if (IsReferenced(package.Id, package.Version))
            {
                return false;
            }

            return true;
        }

 /// <summary>
 /// Check to see if this package applies to a project based on 2 criteria:
 /// 1. The package has project content (i.e. content that can be applied to a project lib or content files)
 /// 2. The package is referenced by any other project
 /// 3. The package has at least one dependecy
 /// 
 /// This logic will probably fail in one edge case. If there is a meta package that applies to a project
 /// that ended up not being installed in any of the projects and it only exists at solution level.
 /// If this happens, then we think that the following operation applies to the solution instead of showing an error.
 /// To solve that edge case we'd have to walk the graph to find out what the package applies to.
 /// 
 /// Technically, the third condition is not totally accurate because a solution-level package can depend on another 
 /// solution-level package. However, doing that check here is expensive and we haven't seen such a package. 
 /// This condition here is more geared towards guarding against metadata packages, i.e. we shouldn't treat metadata packages 
 /// as solution-level ones.
 /// </summary>
 public bool IsProjectLevel(IPackage package)
 {
     return package.HasProjectContent() ||
          package.DependencySets.SelectMany(p => p.Dependencies).Any() ||
         LocalRepository.IsReferenced(package.Id, package.Version);
 }

        protected static PackageTargets GetPackageTarget(IPackage package)
        {
            IV3PackageMetadata v3package = package as IV3PackageMetadata;
            if (v3package != null)
            {
                return v3package.PackageTarget;
            }
            else
            {
                if (package.HasProjectContent())
                {
                    return PackageTargets.Project;
                }

                if (IsDependencyOnly(package))
                {
                    return PackageTargets.None;
                }

                return PackageTargets.External;
            }
        }

 private bool IsSolutionLevel(IPackage package)
 {
     // A package is solution level if it doesn't have project content & doesn't have dependency & not referenced by any project.
     //
     // Technically, the second condition is not totally accurate because a solution-level package can depend on another 
     // solution-level package. However, doing that check here is expensive and we haven't seen such a package. 
     // This condition here is more geared towards guarding against metadata packages, i.e. we shouldn't treat metadata packages 
     // as solution-level ones.
     return !package.HasProjectContent() && 
            !package.DependencySets.SelectMany(p => p.Dependencies).Any() &&
            !IsReferenced(package.Id, package.Version);
 }

		bool IsProjectPackage (IPackage package)
		{
			return package.HasProjectContent () ||
				package.DependencySets.SelectMany (p => p.Dependencies).Any ();
		}

        private static PackageTargets GetPackageTarget(IPackage package)
        {
            if (package.HasProjectContent())
            {
                return PackageTargets.Project;
            }

            if (IsDependencyOnly(package))
            {
                return PackageTargets.None;
            }

            return PackageTargets.External;
        }

 /// <summary>
 /// Check to see if this package applies to a project based on 2 criteria:
 /// 1. The package has project content (i.e. content that can be applied to a project lib or content files)
 /// 2. The package is referenced by any other project
 /// 
 /// This logic will probably fail in one edge case. If there is a meta package that applies to a project
 /// that ended up not being installed in any of the projects and it only exists at solution level.
 /// If this happens, then we think that the following operation applies to the solution instead of showing an error.
 /// To solve that edge case we'd have to walk the graph to find out what the package applies to.
 /// </summary>
 public bool IsProjectLevel(IPackage package)
 {
     return package.HasProjectContent() || _sharedRepository.IsReferenced(package.Id, package.Version);
 }