C# ICollection.Take方法代码示例

        public static void SetUpClass(TestContext context)
        {
            var seq = new SequentialGenerator<int> { Direction = GeneratorDirection.Ascending };
            var gen = new RandomGenerator();

            data_users = Builder<User>
                .CreateListOfSize(10)
                .All()
                    .With(u => u.DisplayName = gen.Phrase(15))
                    .Build();

            data_channels = Builder<Channel>
                .CreateListOfSize(20)
                .All()
                    .With(m => m.Id = seq.Generate())
                    .And(x => x.Name = gen.Phrase(15))
                    .And(x => x.AuthorId = gen.Phrase(10))
                    .And(x => x.Author = data_users.First())
                    .And(x => x.Loops = gen.Boolean())
                    .And(x => x.DateCreated = gen.DateTime())
                    .And(x => x.DateUpdated = x.DateCreated + new TimeSpan(3, 0, 0))
                .Random(10)
                    .With(x => x.DateDeactivated = x.DateUpdated + new TimeSpan(3, 0, 0))
                .Build();

            data_musics = Builder<Music>
                .CreateListOfSize(50)
                .All()
                    .With(m => m.Id = seq.Generate())
                    .And(m => m.LengthInMilliseconds = gen.Int())
                    .And(m => m.SizeInBytes = gen.Int())
                    .And(m => m.DateCreated = gen.DateTime())
                    .And(m => m.DateUpdated = m.DateCreated + new TimeSpan(3, 0, 0))
                .Build();

            channels = new Mock<ChannelService>(null);
            musics = new Mock<MusicService>(null);

            channels
                .Setup(x => x.All())
                .ReturnsAsync(data_channels);

            channels
                .Setup(x => x.Paginate(0, 10))
                .ReturnsAsync(data_channels.Take(10).ToList());

            channels
                .Setup(x => x.ActiveChannels(0, 4))
                .ReturnsAsync(data_channels.Take(4).ToList());

            channels
                .Setup(c => c.Deactivate(It.IsAny<Channel>()))
                .ReturnsAsync(1);
        }

        protected static Lists ListsFromGuidCollection(ICollection<Guid> hashLists, int size, IStorage storage )
        {
            var lists = from listId in hashLists.Take(size)
                        select new ListApi(listId, storage.List.GetInfo(listId));

            return new Lists(lists.ToList());
        }

 private static void AddAlternates(ShapeMetadata metadata, ICollection<string> values)
 {
     for (var i = 0; i < values.Count; i++)
     {
         var alternate = EncodeAlternate($"{metadata.Type}__{String.Join("_", values.Take(i + 1))}");
         metadata.Alternates.Add(alternate);
     }
 }

        // Methods to build the lists to return
        protected static Accounts AccountsFromGuidCollection(ICollection<Guid> hashAccounts, int size, IStorage storage)
        {
            var accounts = from accountId in hashAccounts.Take(size)
                           let accountInfo = storage.Account.GetInfo(accountId)
                           select new Account(accountId, accountInfo.Name, accountInfo.Description);

            return new Accounts(accounts.ToList());
        }

		private static void HandleDoubleWordSurnamePrefix(NameParts result, ICollection<string> parts)
		{
			if (!IsTwoPartSurnamePrefix(parts))
			{
				return;
			}

			result.Surname = String.Join(" ", parts.Skip(parts.Count - 2).Take(2)) + " " + result.Surname;
			result.MiddleName = parts.Count == 2 ? null : String.Join(" ", parts.Take(parts.Count - 2));
		}

        /// <summary>
        /// Setup the critic
        /// </summary>
        protected override void GivenThat()
        {
            base.GivenThat();

            this._movies = new List<IMovie>();

            for (var i = 0; i < 10; i++)
            {
                this._movies.Add(Mock<IMovie>());
            }

            foreach (var movie in _movies.Take(5))
            {
                var movie1 = movie;

                Dep<IMovieCritic>().Stub(c => c.IsViolent(movie1)).Return(true);
            }
        }

        public static int[] SortAndCount(ICollection<int> unsortedArray, out long inversionCount)
        {
            if (unsortedArray.Count <= 1)
            {
                inversionCount = 0;
                return unsortedArray.ToArray();
            }

            int length = unsortedArray.Count;
            int half = length/2;

            long leftInversionCount, rightInversionCount, splitInversionCount;
            var left = SortAndCount(unsortedArray.Take(half).ToArray(), out leftInversionCount);
            var right = SortAndCount(unsortedArray.Skip(half).Take(length - half).ToArray(), out rightInversionCount);
            var sortedArray = MergeAndCount(length, left, right, out splitInversionCount);
            inversionCount = leftInversionCount + rightInversionCount + splitInversionCount;

            return sortedArray;
        }

        private static byte[] PrepareEncodingData(SymmetricAlgorithm algorithm, Random randomProvider, ICollection<byte> data)
        {
            // ограничиваем размер пароля
            var dataLength = (byte)data.Count;
            var preparedBytes = new List<byte> { dataLength };
            preparedBytes.AddRange(data.Take(dataLength));

            // дополняем пароль произвольными символами до размера блока шифрования
            var blockSize = algorithm.BlockSize / 8;
            var additionalBytesCount = preparedBytes.Count % blockSize;
            if (additionalBytesCount > 0)
            {
                additionalBytesCount = blockSize - additionalBytesCount;
                var additionalBytes = new byte[additionalBytesCount];
                randomProvider.NextBytes(additionalBytes);
                preparedBytes.AddRange(additionalBytes);
            }

            return preparedBytes.ToArray();
        }

        public void AddRange(ICollection<Nucleotide> items)
        {
            var nbc = (Count + items.Count + 3)/4;
            if (nbc > _data.Length)
                Array.Resize(ref _data, Math.Max(nbc, _data.Length*2));
            var byteId = Count/4;
            var packId = Count%4;
            var curByte = _data[byteId];
            int skipHeader;
            if (packId > 0)
            {

                var itemHeader = items.Take(4 - packId).ToArray();
                skipHeader = itemHeader.Length;
                for (int i = packId; i < 4 && i < itemHeader.Length+packId; i++)
                {
                    var shift = 2*i;
                    curByte = (byte) ((curByte & ~(0x03 << shift)) | ((int) itemHeader[i - packId] << shift));
                }
                _data[byteId] = curByte;
                Count += skipHeader;
                byteId++;
                packId = 0;
            }
            else
                skipHeader = 0;

            byte tmp = 0;
            foreach (var item in items.Skip(skipHeader))
            {
                var shift = 2*packId;
                tmp =  (byte)(tmp | ((int)item << shift));
                Count++;
                packId = (packId + 1)%4;
                if (packId == 0)
                    _data[byteId++] = tmp;
            }
            if (packId != 0)
                _data[byteId] = tmp;
        }

 public IEnumerable<String> Sort(
     ICollection<String> strings)
 {
     return strings
         .Skip(6)
         .Concat(strings.Skip(2).Take(6))
         .Concat(strings.Take(2));
 }

 private static string BoolArrayToString(ICollection<bool> array)
 {
     var s = new StringBuilder(array.Count);
     foreach (var b in array.Take(10))
     {
         s.Append(b ? '1' : '0');
     }
     return s.ToString();
 }

 private static int CountChangeIter(double x, ICollection<double> changes)
 {
     var n = changes.Count;
     if (n == 0)
     {
         return 0;
     }
     var minChange = changes.Last();
     if (System.Math.Abs(x - minChange) <= 1e-5)
     {
         return 1;
     }
     if (x < minChange)
     {
         return 0;
     }
     return CountChangeIter(x - minChange, changes) + CountChangeIter(x, changes.Take(n - 1).ToList());
 }

        /// <summary>
        /// Determines if the collection of StorageObjects meets the minimum size requirements for a static large object manifest.
        /// </summary>
        /// <param name="segments">A collection of StorageObjects.</param>
        /// <param name="minSegmentSize">The minimum size in bytes for segments.</param>
        /// <returns>A value indicating if the collection meets the minimum size criteria.</returns>
        internal bool HasMinSizeSegments(ICollection<StorageObject> segments, long minSegmentSize)
        {
            segments.AssertIsNotNull("segments", "Cannot ensure that a collection of segments meets minimum size criteria with a null segment collection.");
            var segmentsToCheck = new List<StorageObject>();
            if (segments.Count == 0)
            {
                //If the collection is empty it does not have any segments that are of the min size.
                return false;
            }

            if (segments.Count == 1)
            {
                //If the collection only has one element then it must meet the criteria (even though the spec says the last segment can be any size).
                segmentsToCheck.Add(segments.First());
            }
            else
            {
                //All segments except the last one must be large then the min size.
                segmentsToCheck.AddRange(segments.Take(segments.Count -1));
            }

            return segmentsToCheck.All(s => s.Length > minSegmentSize);
        }

        public void AddRange(ICollection<Nucleotide> items)
        {
            var nbc = (Count + items.Count + 3) / 4;
            if (nbc > _data.Length)
                Array.Resize(ref _data, Math.Max(nbc, _data.Length*2));

            var byteId = Count / 4;
            var packId = Count % 4;
            var curByte = _data[byteId];
            int skipHeader;
            if (packId > 0)
            {

                var itemHeader = items.Take(4 - packId).ToArray();
                skipHeader = itemHeader.Length;
                for (int i = packId; i < 4 && i < itemHeader.Length + packId; i++)
                {
                    var shift = 2 * i;
                    curByte = (byte)((curByte & ~(0x03 << shift)) | ((int)itemHeader[i - packId] << shift));
                }
                _data[byteId] = curByte;
                Count += skipHeader;
                byteId++;
                packId = 0;
            }
            else
                skipHeader = 0;

            byte tmp = 0;
            foreach (var item in items.Skip(skipHeader))
            {
                var shift = 2 * packId;
                tmp = (byte)(tmp | ((int)item << shift));
                Count++;
                packId = (packId + 1) % 4;
                if (packId == 0)
                    _data[byteId++] = tmp;
            }
            if (packId != 0)
                _data[byteId] = tmp;

            // допишем маску. 1 - есть, 0 - нет.
            var mbc = (Count + items.Count + 7) / 8;
            if (mbc > _mask.Length)
                Array.Resize(ref _mask, Math.Max(mbc, _mask.Length * 2));

            int pos = Count - items.Count;
            foreach (var item in items)
            {
                if (item != Nucleotide.Any)
                    _mask[pos/8] |= (byte)(1 << (pos%8));
                pos++;
            }
            _maskSizes = null;
        }

 private ICollection<IPlayer> GetTop5Results(ICollection<IPlayer> players)
 {
     return players.Take(5).ToList();
 }