C# IReadOnlyList.Except方法代码示例

        public IReadOnlyList<IUniverseDao> GetOrCreate(IReadOnlyList<string> universeNames)
        {
            var existing = Context.Universes.Where(u => universeNames.Contains(u.Name)).ToImmutableList();

            var missingNames = universeNames.Except(existing.Select(u => u.Name));
            var allUniverses = new List<UniverseDao>(existing);

            foreach (var name in missingNames)
            {
                var universe = new UniverseDao { Name = name };
                Context.Universes.Add(universe);
                allUniverses.Add(universe);
            }

            Context.SaveChanges();
            return allUniverses;
        }

        protected virtual Uri PickNewServer(Uri lastServer, IReadOnlyList<Uri> serverPool)
        {
            if (!serverPool.Any())
            {
                throw new NoServersAvailableException();
            }

            if (serverPool.Count == 1)
            {
                return serverPool[0];
            }

            if (lastServer != null)
            {
                serverPool = serverPool.Except(new[] { lastServer }).ToList();
            }

            if (!serverPool.Any())
            {
                if (lastServer == null)
                {
                    throw new NoServersAvailableException();
                }

                return lastServer;
            }

            if (serverPool.Count == 1)
            {
                return serverPool[0];
            }

            _server++;
            int index = _server;
            return serverPool[index % serverPool.Count];
        }

        private async Task<IEnumerable<TenantResource>> FindTenantsByName(IReadOnlyList<string> tenantNames)
        {
            if (!tenantNames.Any())
            {
                return Enumerable.Empty<TenantResource>();
            }

            if (tenantNames.Contains("*"))
            {
                return await repository.Tenants.FindAll().ConfigureAwait(false);
            }

            var tenantsByName = await repository.Tenants.FindByNames(tenantNames).ConfigureAwait(false);
            var missing = tenantsByName == null || !tenantsByName.Any()
                ? tenantNames.ToArray()
                : tenantNames.Except(tenantsByName.Select(e => e.Name), StringComparer.OrdinalIgnoreCase).ToArray();

            var tenantsById = await repository.Tenants.Get(missing).ConfigureAwait(false);

            missing = tenantsById == null || !tenantsById.Any()
                ? missing
                : missing.Except(tenantsById.Select(e => e.Id), StringComparer.OrdinalIgnoreCase).ToArray();

            if (missing.Any())
            {
                throw new ArgumentException($"Could not find the {"tenant" + (missing.Length == 1 ? "" : "s")} {string.Join(", ", missing)} on the Octopus server.");
            }

            var allTenants = Enumerable.Empty<TenantResource>();
            if (tenantsById != null)
            {
                allTenants = allTenants.Concat(tenantsById);
            }
            if (tenantsByName != null)
            {
                allTenants = allTenants.Concat(tenantsByName);
            }

            return allTenants;
        }

            public async void UpdateFolders(IReadOnlyList<StorageFolder> folders)
            {
                var futureAccessList = StorageApplicationPermissions.FutureAccessList;
                var oldFolders = await GetFolders();

                var toRemove = oldFolders.Except(folders).ToList();
                _watchedProvider.RemoveFolders(toRemove);

                var toAdd = folders.Except(oldFolders).ToList();
                foreach (var folder in toAdd)
                {
                    if (!futureAccessList.CheckAccess(folder))
                        futureAccessList.Add(folder);
                }
                _watchedProvider.AddFolders(toAdd);
                _playlistFile.SetFolders(folders);
            }