C# IReadOnlyList.Max方法代码示例

		public Series1(IReadOnlyList<TReal> xValues, IReadOnlyList<TReal> yValues, IReadOnlyList<TReal> widthValues, IReadOnlyList<TReal> heightValues)
		{
			RequiresNotNull(xValues, yValues, heightValues, widthValues);
			Requires(xValues.Count == yValues.Count);
			Requires(xValues.Count == heightValues.Count);
			Requires(xValues.Count == widthValues.Count);

			XValues = xValues;
			YValues = yValues;
			HeightValues = heightValues;
			WidthValues = widthValues;

			if (xValues.Count > 0)
			{
				XRange = new VisibleRange(xValues.Min(), xValues.Max());
				YRange = new VisibleRange(yValues.Min(), yValues.Max());
			}
			else
			{
				XRange = new VisibleRange(0, 0);
				YRange = new VisibleRange(0, 0);
			}
		}

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

        /// <summary>
        /// Отрисовка графика спектра
        /// </summary>
        private void DrawSpectrum(PaintEventArgs e, IReadOnlyList<int> spectrum, Color color)
        {
            var k = (float) (panel.Height - 30)/(spectrum.Max() - spectrum.Min());
            var k2 = panel.Width/((float) spectrum.Count/5);
            var k3 = (float) 25000/spectrum.Count;

            //отрисуем координаты
            DrawLine(new Point(panel.Left, panel.Bottom - 15), new Point(panel.Right, panel.Bottom - 15), e, Color.Black);
            for (int i = 0; i < 5000; i += 500)
            {
                DrawLine(new Point((int) ((i/k3)*k2), panel.Bottom - 13),
                    new Point((int) ((i/k3)*k2), panel.Bottom - 17), e, Color.Black);
                e.Graphics.DrawString(i.ToString(), new Font("Arial", 7), new SolidBrush(Color.Black),
                    panel.Left + (int) ((i/k3)*k2), panel.Bottom - 15);
            }

            for (int i = 1; i < spectrum.Count; i++)
                DrawLine(new Point((int) (k2*(i - 1)), panel.Bottom - (int) (k*spectrum[i - 1]) - panel.Top - 20),
                    new Point((int) (k2*i), panel.Bottom - (int) (k*spectrum[i]) - panel.Top - 20), e,
                    color);
        }

        /// <summary>
        /// Formats the provided strings into a single, columnized string.
        /// </summary>
        /// <param name="values">The values to format.</param>
        /// <param name="screenBufferWidth">The width of the intended output
        /// screen buffer, in characters.</param>
        /// <returns>The formatted string.</returns>
        public static string FormatInColumns(IReadOnlyList<string> values, int screenBufferWidth)
        {
            const int spaceBetweenCols = 2;

            if (values.Count == 0) return string.Empty;

            var builder = new StringBuilder();

            var maxLength = values.Max(v => v.Length);

            var colWidth = Math.Min(maxLength + spaceBetweenCols, screenBufferWidth);

            var cols = Math.Max(1, screenBufferWidth / colWidth);

            var lastColWidth = screenBufferWidth - colWidth * (cols - 1);

            var rows = values.Count / cols;
            if (values.Count % cols != 0)
            {
                ++rows;
            }

            for (var rowIndex = 0; rowIndex < rows; ++rowIndex)
            {
                var charsInCol = 0;
                for (var colIndex = 0; colIndex < cols; ++colIndex)
                {
                    var index = colIndex * rows + rowIndex;
                    if (index >= values.Count)
                    {
                        builder.AppendLine();
                        break;
                    }

                    var thisColWidth = (colIndex == cols - 1) ? lastColWidth : colWidth;

                    var format = "{0,-" + thisColWidth + "}";
                    builder.AppendFormat(CultureInfo.CurrentCulture, format, values[index]);

                    charsInCol += values[index].Length;
                }

                if (charsInCol > screenBufferWidth)
                {
                    builder.AppendLine();
                }
            }

            return builder.ToString();
        }

        Tuple<int, IEnumerable<PlacedWordRectangle>> GetHorizontalStripe(Size wordSize,
            IReadOnlyList<PlacedWordRectangle> alreadyPlacedWords)
        {
            var minUsedY = alreadyPlacedWords.Min(view => view.Position.Y);
            var maxUsedY = alreadyPlacedWords.Max(view => view.Position.Y + view.Size.Height);

            var minPositionY = Math.Max(0, minUsedY - wordSize.Height + 1);
            var maxPositionY = Math.Min(Size.Height, maxUsedY + wordSize.Height - 1) - wordSize.Height;
            var positionY = minPositionY + (int)Math.Round(random.NextDouble() * (maxPositionY - minPositionY));

            var wordsOnStripe = alreadyPlacedWords
                .Where(view => AreSegmentsIntersect(positionY, positionY + wordSize.Height,
                    view.Position.Y, view.Position.Y + view.Size.Height));
            return Tuple.Create(positionY, wordsOnStripe);
        }

        private PointCollection GetPointCollection(IReadOnlyList<int> values)
        {
            var max = values.Max();

            // first point (lower-left corner)
            var points = new PointCollection {new Point(0, max)};
            // middle points
            for (var i = 0; i < values.Count; i++)
            {
                points.Add(new Point(i, max - values[i]));
            }
            // last point (lower-right corner)
            points.Add(new Point(values.Count - 1, max));
            return points;
        }