C# PackageDescriptor类代码示例

            protected void when_finding_packages(string dependency)
            {
                var dep = new PackageDescriptor();
                ((IPackageDescriptor)dep).Dependencies.Add(DependsParser.ParseDependsLine(dependency));

                FoundPackage = Repository.PackagesByName.FindAll(dep.Dependencies.First()).FirstOrDefault();
            }

            protected void when_finding_packages(string dependency)
            {
                var dep = new PackageDescriptor();
                new DependsParser().Parse(dependency, dep);

                FoundPackage = Repository.FindAll(dep.Dependencies.First()).FirstOrDefault();
            }

 public void Parse(string line, PackageDescriptor descriptor)
 {
     var match = _regex.Match(line);
     if (!match.Success)
         return;
     ParseContent(match.Groups["content"].Value, descriptor);
 }

 public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageResolver resolver,
     bool includeContentOnly,
     ExecutionEnvironment exec,
     PackageDescriptor descriptor,
     params IPackageRepository[] repositories)
 {
     return GetAssemblyReferences(resolver.TryResolveDependencies(descriptor, repositories), exec, includeContentOnly);
 }

        public IPackageCleanResult CleanProjectPackages(PackageDescriptor packages, IPackageRepository projectRepository, string name, PackageCleanOptions options = PackageCleanOptions.Default)
        {
            if (packages == null) throw new ArgumentNullException("packages");
            if (projectRepository == null) throw new ArgumentNullException("projectRepository");

            var repoForClean = projectRepository as ISupportCleaning;
            if (repoForClean == null) throw new ArgumentException("projectRepository must implement ISupportCleaning");
            return new PackageCleanResultIterator(CleanProjectPackagesCore(packages, repoForClean, x => name.EqualsNoCase(x)));
        }

 public DefaultPackageInfo(string packageFileName, Version versionFileContent, PackageDescriptor descriptor)
 {
     _descriptor = descriptor;
     _packageVersion = versionFileContent
                       ?? descriptor.Version
                       ?? PackageNameUtility.GetVersion(packageFileName);
     _packageName = PackageNameUtility.GetName(packageFileName);
     Identifier = new PackageIdentifier(Name, Version);
 }

 public static IPackageDescriptor Lock(this IPackageDescriptor descriptor, IPackageRepository repository, string scope = null)
 {
     scope = scope ?? string.Empty;
     var lockedRepo = repository.Feature<ISupportLocking>();
     if (lockedRepo == null)
         return descriptor;
     var lockedDescriptor = new PackageDescriptor(descriptor);
     var lockedPackages = lockedRepo.LockedPackages[scope];
     return Lock(lockedDescriptor, lockedPackages);
 }

        public void Write(PackageDescriptor descriptor, Stream descriptorStream)
        {
            var streamWriter = new StreamWriter(descriptorStream, Encoding.UTF8);
            var lines = from parser in _lineParsers
                        from parserLine in parser.Write(descriptor)
                        select parserLine;

            var content = lines.Join("\r\n");
            streamWriter.Write(content);
            streamWriter.Flush();
        }

 public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory)
 {
     CurrentDirectory = currentDirectory;
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current directory repository");
     RemoteRepositories = new List<InMemoryRepository> { RemoteRepository };
     DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc");
     Descriptor = new PackageDescriptor();
     ConfigurationDirectory = configDirectory;
 }

 public dependency_resolver_context()
 {
     DependencyDescriptor = new PackageDescriptor
     {
             Name = "test",
             SemanticVersion = "1.0".ToSemVer()
     };
     ProjectRepository = new InMemoryRepository("Local repository");
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current repository");
 }

        public PackageDescriptor Read(Stream content)
        {
            var stringReader = new StreamReader(content, true);
            var lines = stringReader.ReadToEnd().GetUnfoldedLines();

            var descriptor = new PackageDescriptor();
            foreach (var line in lines)
                foreach (var parser in _lineParsers)
                    parser.Parse(line, descriptor);

            return descriptor;
        }

 static PackageContent GenerateDescriptorFile(PackageDescriptor descriptor)
 {
     var descriptorStream = new MemoryStream();
     new PackageDescriptorReaderWriter().Write(descriptor, descriptorStream);
     return new PackageContent
     {
         FileName = descriptor.Name + ".wrapdesc",
         RelativePath = ".",
         Stream = descriptorStream.ResetOnRead(),
         Size = descriptorStream.Length
     };
 }

 public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory)
 {
     CurrentDirectory = currentDirectory;
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current directory repository");
     RemoteRepositories = new List<InMemoryRepository> { RemoteRepository };
     DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc").MustExist();
     Descriptor = new PackageDescriptor();
     ConfigurationDirectory = configDirectory;
     ScopedDescriptors = new Dictionary<string, FileBased<IPackageDescriptor>>(StringComparer.OrdinalIgnoreCase);
     ScopedDescriptors[string.Empty] = FileBased.New(DescriptorFile, Descriptor);
 }

        public IPackageAddResult AddProjectPackage(PackageRequest packageToAdd,
            IEnumerable<IPackageRepository> sourceRepositories,
            PackageDescriptor projectDescriptor,
            IPackageRepository projectRepository,
            PackageAddOptions options = PackageAddOptions.Default)
        {
            Check.NotNull(packageToAdd, "packageToAdd");
            Check.NoNullElements(sourceRepositories, "sourceRepositories");
            Check.NotNull(projectDescriptor, "projectDescriptor");
            Check.NotNull(projectRepository, "projectRepository");

            return new PackageAddResultIterator(AddProjectPackageCore(packageToAdd, sourceRepositories, projectDescriptor, projectRepository, options));
        }

 /// <summary>
 /// Retrieves a suitable package to put a certain type into.
 /// </summary>
 /// <param name="type">type for which a suitable package is desired</param>
 /// <returns>suitable package</returns>
 public PackageDescriptor GetPackage(Type type)
 {
     string pkgName = type.Namespace;
     if (pkgName == null)
         pkgName = "DefaultPackage";
     PackageDescriptor pd;
     if (!_pkgMap.TryGetValue(pkgName, out pd))
     {
         pd = new PackageDescriptor(pkgName);
     }
     _pkgMap[pkgName] = pd;
     _design.AddChild(pd, pd.Name);
     return pd;
 }