C# IReadOnlyCollection.Contains方法代码示例

 private static IEnumerable<int> getSizes(IReadOnlyCollection<string> args)
 {
     var numberOfFilesystemArguments = args.Contains(recursive) ? 2 : 1;
     var sizes = args.Count == numberOfFilesystemArguments
         ? defaultSizes
         : args.Skip(numberOfFilesystemArguments).Select(a => Convert.ToInt32(a));
     return sizes;
 }

 private void TasClientOnFriendListUpdated(object sender, IReadOnlyCollection<string> friends)
 {
     foreach (var battleID in Program.TasClient.ExistingUsers.Values.Where(b => friends.Contains(b.Name) && b.BattleID.HasValue).Select(x=>x.BattleID))
     {
         var battleIcon = GetBattleIcon(battleID??0);
         battleIcon.SetPlayers();
         BattleChanged(this, new EventArgs<BattleIcon>(battleIcon));
     }
 }

 private void TasClientOnFriendListUpdated(object sender, IReadOnlyCollection<string> friends)
 {
     foreach (var battle in Program.TasClient.ExistingBattles.Values.Where(b => b.Users.Any(y => friends.Contains(y.Key))))
     {
         var battleIcon = GetBattleIcon(battle.BattleID);
         battleIcon.SetPlayers();
         BattleChanged(this, new EventArgs<BattleIcon>(battleIcon));
     }
 }

        /// <summary>
        /// The files in a project.
        /// </summary>
        /// <param name="fileExtensionFilter">Any file extensions to filter out. If empty, all file extensions are returned.</param>
        /// <returns></returns>
        public IEnumerable<TfsFile> Files(IReadOnlyCollection<string> fileExtensionFilter)
        {
            var projectDir = Path.GetDirectoryName(ServerPath);

            return _projectDocument.Value
                .Descendants(XName.Get("Compile", ProjectNamespace)).Concat(_projectDocument.Value
                .Descendants(XName.Get("None", ProjectNamespace)))
                .Select(e => Path.Combine(projectDir, e.Attribute(XName.Get("Include")).Value))
                .Where(p => fileExtensionFilter.Count == 0 || fileExtensionFilter.Contains(Path.GetExtension(p)))
                .Select(p => VersionControl.GetItem(p))
                .Select(i => new TfsFile(i, VersionControl));
        }

        private void RemoveLines(IReadOnlyCollection<int> indices) {
            var visualsToRemove = new List<VisualTextLine>();

            foreach (var visual in visuals) {
                var line = (VisualTextLine)visual;

                if (indices.Contains(line.Index)) {
                    visualsToRemove.Add(line);
                }
            }
            foreach (var line in visualsToRemove) {
                visuals.Remove(line);
            }
        }

 public static FindSpecification<Model.Statistics.FirmCategory3> ByProjectAndCategories(long projectId, IReadOnlyCollection<long?> categoryIds)
 {
     return new FindSpecification<Model.Statistics.FirmCategory3>(x => x.ProjectId == projectId && categoryIds.Contains(x.CategoryId));
 }

 public static FindSpecification<ProjectCategory> ProjectCategories(IReadOnlyCollection<long> aggregateIds)
 {
     return new FindSpecification<ProjectCategory>(x => aggregateIds.Contains(x.ProjectId));
 }

 public static FindSpecification<FirmTerritory> FirmTerritories(IReadOnlyCollection<long> aggregateIds)
 {
     return new FindSpecification<FirmTerritory>(x => aggregateIds.Contains(x.FirmId));
 }

 public static FindSpecification<ClientContact> ClientContacts(IReadOnlyCollection<long> aggregateIds)
 {
     return new FindSpecification<ClientContact>(x => aggregateIds.Contains(x.ClientId));
 }

 private static void CompareWrap(ObservableCollection<string> targetColl, IReadOnlyCollection<string> wcoll, string t1, string t2)
 {
     Assert.AreEqual(targetColl.Count, wcoll.Count);
     Assert.AreEqual(targetColl.Contains(t1), wcoll.Contains(t1));
     Assert.AreEqual(targetColl.Contains(t2), wcoll.Contains(t2));
     for (int i = 0; i < targetColl.Count; i++)
     {
         Assert.AreEqual(targetColl[i], wcoll[i]);
     }
 }

		void ModelChildrenCollectionChanged(IReadOnlyCollection<object> removedItems, IReadOnlyCollection<object> addedItems)
		{
			if (!IsVisible) {
				SwitchBackToLazyLoading();
				return;
			}
			Children.RemoveAll(n => removedItems.Contains(n.Model));
			InsertChildren(addedItems);
		}

        public async Task<IDictionary<int, string>> GetEmailAddressesForUserKeysAsync(IReadOnlyCollection<int> distinctUserKeys)
        {
            var results = await UserRepository.GetAll()
                .Where(u => distinctUserKeys.Contains(u.Key))
                .Select(u => new { u.Key, u.EmailAddress })
                .ToDictionaryAsync(u => u.Key, u => u.EmailAddress);

            return results;
        }

		/// <summary>
		/// Убедиться в корректности списка ролей пользователя
		/// </summary>
		/// <param name="roles">Список ролей</param>
		/// <exception cref="IncorrectRoleListException">Список ролей некорректен</exception>
		private static void AssertRoleListCorrectness(IReadOnlyCollection<string> roles)
		{
			if (roles.Contains("buildserver") && roles.Count > 1)
			{
				throw new IncorrectRoleListException();
			}
		}

        private void RunAlbumWorkflows(
            IReadOnlyCollection<IITTrack> tracksToFix,
            IReadOnlyCollection<Workflow> albumWorkflows)
        {
            if (albumWorkflows.Count == 0)
            {
                return;
            }

            NewState(0, tracksToFix.Count, "Generating album list...");

            var albums = new Dictionary<string,List<IITTrack>>();

            foreach (var track in tracksToFix)
            {
                if (!albums.ContainsKey(track.Album))
                {
                    albums.Add(track.Album, new List<IITTrack> {track});
                }
                else
                {
                    albums[track.Album].Add(track);
                }

                ItemsProcessed++;
            }

            NewState(0, albums.Count, "Running album workflows...");

            foreach (var album in albums)
            {
                // have to set number before count in case old number is higher than count
                if (albumWorkflows.Contains(Workflow.FixTrackNumbers))
                {
                    var trackComparer = TrackComparerFactory.GetTrackComparer(album.Value);
                    album.Value.Sort(trackComparer);
                    for (var i = 0; i < album.Value.Count; i++)
                    {
                        album.Value[i].TrackNumber = i + 1;
                    }
                }

                if (albumWorkflows.Contains(Workflow.FixCountOfTracksOnAlbum))
                {
                    foreach (var track in album.Value)
                    {
                        track.TrackCount = album.Value.Count;
                    }
                }

                ItemsProcessed++;
            }
        }

		public async Task RemoveAuctions(IReadOnlyCollection<int> ids, string removingUserId, IValidationErrorNotifier errors)
		{
			var auctions = await mContext.Auctions.Include(x => x.Offers).Where(x => ids.Contains(x.Id)).ToListAsync();
			if(!await auctions.All(async x => await CanBeRemoved(x, removingUserId, errors)))
				return;

			await mContext.Auctions.Where(x => ids.Contains(x.Id)).DeleteAsync();

			foreach(var auctionId in ids)
			{
				RemoveAuctionPhotos(auctionId);
			}
		}