C# IReadOnlyList.Take方法代码示例

 public override Actuator CreateItem(LegacyMapBuilder context, Tile currentTile, IReadOnlyList<ActuatorItemData> matchedSequence)
 {
     return new SwitchSequenceActuator(
         context.GetWallPosition(matchedSequence[0].TilePosition, context.WallActuatorCreator.CurrentTile),
         matchedSequence.Take(matchedSequence.Count - 1).Select(context.GetTargetTile),
         matchedSequence.Take(matchedSequence.Count - 1).Select(x => x.GetActionStateX()))
     {
         UpTexture = context.WallTextures[matchedSequence[0].Decoration - 1],
         DownTexture = context.WallTextures[matchedSequence[1].Decoration - 1]
     };
 }

 private static List<string> RemoveTrailingEmptyLines(IReadOnlyList<string> lines)
 {
     var end = lines.Count - 1;
     while (end >= 0 && string.IsNullOrWhiteSpace(lines[end]))
     {
         end--;
     }
     return lines.Take(end + 1).ToList();
 }

        public HttpFileSystemBasedFindPackageByIdResource(IReadOnlyList<Uri> baseUris)
        {
            if (baseUris == null)
            {
                throw new ArgumentNullException(nameof(baseUris));
            }

            if (baseUris.Count < 1)
            {
                throw new ArgumentException(Strings.OneOrMoreUrisMustBeSpecified, nameof(baseUris));
            }

            _baseUris = baseUris
                .Take(MaxRetries)
                .Select(uri => uri.OriginalString.EndsWith("/", StringComparison.Ordinal) ? uri : new Uri(uri.OriginalString + "/"))
                .ToList();
            _httpSource = new HttpSource(_baseUris[0], userName: null, password: null);
        }

        public Bitmap CombineSlices(IReadOnlyList<Bitmap> slices, int slicesPerImage)
        {
            var sliceImages = slices.Take(50).Shuffle().Take(slicesPerImage).ToArray();
             var orderedSliceImages = sliceImages.OrderBy(sliceImage => {
            var grayscaleImage = grayscaleFilter.Apply(sliceImage);
            return new HorizontalIntensityStatistics(grayscaleImage).Gray.TotalCount;
             }).ToList();
             var shuffledSliceImages = thumbnailGeneratorUtilities.HalfShuffle(orderedSliceImages);

             var sliceSize = sliceImages.First().Size;
             var resultImage = new Bitmap(sliceSize.Width * slicesPerImage, sliceSize.Height);
             using (var g = Graphics.FromImage(resultImage)) {
            for (var i = 0; i < slicesPerImage; i++) {
               g.DrawImage(
                  shuffledSliceImages[i],
                  new Rectangle(i * sliceSize.Width, 0, sliceSize.Width, sliceSize.Height),
                  new Rectangle(0, 0, sliceSize.Width, sliceSize.Height),
                  GraphicsUnit.Pixel);
            }
             }
             return resultImage;
        }

        private Tuple<Uri, string> ParseArguments(CommandContext context, IReadOnlyList<string> args)
        {
            if (args.Count == 0)
            {
                return new Tuple<Uri, string>(null, null);
            }

            var lastArgument = ParseUri(args[args.Count - 1]);

            Uri imageUrl = null;
            string message;

            if (lastArgument != null)
            {
                imageUrl = lastArgument;
                message = args.Count > 1 ? String.Join(" ", args.Take(args.Count - 1)) : null;
            }
            else
            {
                message = String.Join(" ", args);
            }

            return new Tuple<Uri, string>(imageUrl, message);
        }

 private static IReadOnlyList<WriteRequest> CreateProcessedRequests(IReadOnlyList<WriteRequest> requests, IReadOnlyList<BulkWriteOperationError> writeErrors, bool isOrdered)
 {
     if (!isOrdered || writeErrors.Count == 0)
     {
         return requests;
     }
     else
     {
         var processedCount = writeErrors.Max(e => e.Index) + 1;
         return requests.Take(processedCount).ToList();
     }
 }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs.Take(_x);
 }

        // The assembly info must be in the last minus 1 position because:
        // - assemblyInfo should be in the end to override attributes
        // - assemblyInfo cannot be in the last position, because last file contains the main
        private static IEnumerable<string> GetSourceFiles(IReadOnlyList<string> sourceFiles, string assemblyInfo)
        {
            if (!sourceFiles.Any())
            {
                yield return assemblyInfo;
                yield break;
            }

            foreach (var s in sourceFiles.Take(sourceFiles.Count() - 1))
                yield return s;

            yield return assemblyInfo;

            yield return sourceFiles.Last();
        }

        private FrameworkElement CreatePreviewElement(IReadOnlyList<object> previewItems)
        {
            if (previewItems == null || previewItems.Count == 0)
            {
                return null;
            }

            const int MaxItems = 3;
            if (previewItems.Count > MaxItems)
            {
                previewItems = previewItems.Take(MaxItems).Concat("...").ToList();
            }

            var grid = new Grid();

            foreach (var previewItem in previewItems)
            {
                var previewElement = GetPreviewElement(previewItem);

                // no preview element
                if (previewElement == null)
                {
                    continue;
                }

                // the very first preview
                if (grid.RowDefinitions.Count == 0)
                {
                    grid.RowDefinitions.Add(new RowDefinition());
                }
                else
                {
                    grid.RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
                }

                // set row position of the element
                Grid.SetRow(previewElement, grid.RowDefinitions.Count - 1);

                // add the element to the grid
                grid.Children.Add(previewElement);

                // set width of the grid same as the first element
                if (grid.Children.Count == 1)
                {
                    grid.Width = previewElement.Width;
                }
            }

            if (grid.Children.Count == 0)
            {
                // no preview
                return null;
            }

            // if there is only 1 item, just take preview element as it is without grid
            if (grid.Children.Count == 1)
            {
                var preview = grid.Children[0];

                // we need to take it out from visual tree
                grid.Children.Clear();

                return (FrameworkElement)preview;
            }

            return grid;
        }

        private FrameworkElement CreatePreviewElement(IReadOnlyList<object> previewItems)
        {
            if (previewItems == null || previewItems.Count == 0)
            {
                return null;
            }

            const int MaxItems = 3;
            if (previewItems.Count > MaxItems)
            {
                previewItems = previewItems.Take(MaxItems).Concat("...").ToList();
            }

            var grid = new Grid();

            for (var i = 0; i < previewItems.Count; i++)
            {
                var previewItem = previewItems[i];

                FrameworkElement previewElement = null;
                if (previewItem is IWpfDifferenceViewer)
                {
                    _previewDiffViewer = (IWpfDifferenceViewer)previewItem;
                    previewElement = _previewDiffViewer.VisualElement;
                    PreviewDockPanel.Background = _previewDiffViewer.InlineView.Background;
                }
                else if (previewItem is string)
                {
                    previewElement = GetPreviewForString((string)previewItem);
                }
                else if (previewItem is FrameworkElement)
                {
                    previewElement = (FrameworkElement)previewItem;
                }

                var rowDefinition = i == 0 ? new RowDefinition() : new RowDefinition() { Height = GridLength.Auto };
                grid.RowDefinitions.Add(rowDefinition);

                Grid.SetRow(previewElement, grid.RowDefinitions.IndexOf(rowDefinition));
                grid.Children.Add(previewElement);

                if (i == 0)
                {
                    grid.Width = previewElement.Width;
                }
            }

            var preview = grid.Children.Count == 0 ? (FrameworkElement)grid.Children[0] : grid;
            return preview;
        }

		protected virtual IReadOnlyList<SqlColumnDeclaration> VisitColumnDeclarations(IReadOnlyList<SqlColumnDeclaration> columns)
		{
			var i = 0;
			List<SqlColumnDeclaration> alternate = null;

			foreach (var column in columns)
			{
				var e = this.Visit(column.Expression);

				if (alternate == null && e != column.Expression)
				{
					alternate = columns.Take(i).ToList();
				}

				alternate?.Add(new SqlColumnDeclaration(column.Name, e));

				i++;
			}

			return alternate != null ? alternate.ToReadOnlyCollection() : columns;
		}

        protected virtual IReadOnlyList<SqlColumnDeclaration> VisitColumnDeclarations(IReadOnlyList<SqlColumnDeclaration> columns)
        {
            List<SqlColumnDeclaration> alternate = null;

            for (int i = 0, n = columns.Count; i < n; i++)
            {
                var column = columns[i];
                var e = this.Visit(column.Expression);

                if (alternate == null && e != column.Expression)
                {
                    alternate = columns.Take(i).ToList();
                }

                if (alternate != null)
                {
                    alternate.Add(new SqlColumnDeclaration(column.Name, e));
                }
            }

            if (alternate != null)
            {
                return alternate.ToReadOnlyList();
            }

            return columns;
        }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            // Get the feed
            Feed feed = new Feed
            {
                ID = _feedId?.Invoke<Uri>(context),
                Title = _feedTitle?.Invoke<string>(context),
                Description = _feedDescription?.Invoke<string>(context),
                Author = _feedAuthor?.Invoke<string>(context),
                Published = _feedPublished?.Invoke<DateTime?>(context),
                Updated = _feedUpdated?.Invoke<DateTime?>(context),
                Link = _feedLink?.Invoke<Uri>(context),
                ImageLink = _feedImageLink?.Invoke<Uri>(context),
                Copyright = _feedCopyright?.Invoke<string>(context)
            };

            // Add items
            foreach (IDocument input in inputs.Take(_maximumItems))
            {
                feed.Items.Add(new FeedItem
                {
                    ID = _itemId?.Invoke<Uri>(input, context),
                    Title = _itemTitle?.Invoke<string>(input, context),
                    Description = _itemDescription?.Invoke<string>(input, context),
                    Author = _itemAuthor?.Invoke<string>(input, context),
                    Published = _itemPublished?.Invoke<DateTime?>(input, context),
                    Updated = _itemUpdated?.Invoke<DateTime?>(input, context),
                    Link = _itemLink?.Invoke<Uri>(input, context),
                    ImageLink = _itemImageLink?.Invoke<Uri>(input, context),
                    Content = _itemContent?.Invoke<string>(input, context),
                    ThreadLink = _itemThreadLink?.Invoke<Uri>(input, context),
                    ThreadCount = _itemThreadCount?.Invoke<int?>(input, context),
                    ThreadUpdated = _itemThreadUpdated?.Invoke<DateTime?>(input, context)
                });
            }

            // Generate the feeds
            return new[]
            {
                GenerateFeed(FeedType.Rss, feed, _rssPath, context),
                GenerateFeed(FeedType.Atom, feed, _atomPath, context),
                GenerateFeed(FeedType.Rdf, feed, _rdfPath, context)
            }.Where(x => x != null);
        }