C# IPackageRepository.Feature方法代码示例

 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);
 }

        IEnumerable<ICommandOutput> ValidateInputs()
        {
            // TODO: HACK HACK HACK
            var namedRepository = Remotes.PublishRepositories(Remote).SelectMany(_ => _).FirstOrDefault();

            if (namedRepository == null)
            {
                yield return new UnknownRemoteName(Remote);
                foreach (var _ in HintRemoteRepositories()) yield return _;
                yield break;
            }

            if ((Username != null && Password == null) || (Username == null && Password != null))
            {
                yield return new IncompleteCredentials();
                yield break;
            }

            bool hasAuth = Username != null && Password != null;
            if (hasAuth) _credentials = new NetworkCredential(Username, Password);
            _authenticationSupport = namedRepository.Feature<ISupportAuthentication>();
            if (hasAuth && _authenticationSupport == null)
            {
                yield return new RemoteAuthenticatioNotSupported(namedRepository);
                yield break;
            }

            _authenticationSupport = _authenticationSupport ?? new NullAuthentication();

            //_repositories = namedRepository.
            _remoteRepository = namedRepository;
            var publishingRepo = _remoteRepository.Feature<ISupportPublishing>();

            if (publishingRepo == null)
            {
                yield return new Error("Repository '{0}' doesn't support publishing.", namedRepository.Name);
                yield break;
            }
            if (Path != null)
            {
                var packageFile = FileSystem.GetFile(Path);
                if (!packageFile.Exists)
                {
                    yield return new FileNotFound(Path);
                    yield break;
                }
                _packageStream = packageFile.OpenRead;
                _packageFileName = packageFile.Name;
                // TODO: This looks iffy at best
                var package = new ZipFilePackage(packageFile);
                _packageName = package.Name;
                _packageVersion = package.SemanticVersion;
            }
            else if (Name != null)
            {
                // get latest version of the Named package
                if (!HostEnvironment.CurrentDirectoryRepository.PackagesByName.Contains(Name))
                {
                    yield return new Error("No package named '{0}' was found.", Name);
                    yield break;
                }
                var packageToCopy = HostEnvironment.CurrentDirectoryRepository.PackagesByName[Name].OrderByDescending(x => x.SemanticVersion).First();
                _packageStream = () => packageToCopy.Load().OpenStream();
                _packageFileName = packageToCopy.FullName + ".wrap";
                _packageName = packageToCopy.Name;
                _packageVersion = packageToCopy.SemanticVersion;
            }
            else
            {
                yield return new Error("Please specify either a file path using the -Path input, or a name using -Name.");
            }
        }

 ICollection<RemoteRepositoryEndpoint> ToPublishEndpoints(IPackageRepository repo)
 {
     if (repo == null || repo.Feature<ISupportPublishing>() == null) return new List<RemoteRepositoryEndpoint>(0);
     return new List<RemoteRepositoryEndpoint>
     {
         new RemoteRepositoryEndpoint
         {
             Token = repo.Token,
             Username = Username,
             Password = Password
         }
     };
 }