C# IList.Aggregate方法代码示例

        public static string FindPositionPart(IList<string> parts, int cursorPosition, out int foundPartsIndex, out int cursorInPartPosition)
        {
            cursorInPartPosition = 0;
              var partsComplete = parts.Aggregate(String.Empty, (aggr, s) => aggr + s);
              for (int i = 0; i < parts.Count(); i++) {
            var partsLower = parts.Take(i).Aggregate(String.Empty, (aggr, s) => aggr + s);
            var partsUpper = parts.Take(i + 1).Aggregate(String.Empty, (aggr, s) => aggr + s);

            var b = partsLower.Length;
            var t = partsUpper.Length;

            if ((cursorPosition >= b && cursorPosition < t) || partsUpper == partsComplete) {
              if (parts[i] == WorkDayParser.itemSeparator.ToString() || parts[i] == WorkDayParser.hourProjectInfoSeparator.ToString()) {
            // cursor left of separator
            foundPartsIndex = i - 1;
            var prevPart = parts.ElementAt(foundPartsIndex);
            // find out where in the found part the cursor is, need to use prevpart an its length
            cursorInPartPosition = prevPart.Length;
            return prevPart;
              } else {
            // find out where in the found part the cursor is
            cursorInPartPosition = cursorPosition - b;
            foundPartsIndex = i;
            return parts.ElementAt(i);
              }
            }
              }
              // not found
              foundPartsIndex = -1;
              return String.Empty;
        }

 public Borda Unpack(IList<string> files, string key)
 {
     var borda = new Borda();
     return files.Aggregate(borda,
         (b, file) => b + Unpack(file, key));
 }

 private static void MorphPart(RenderMeshPart part, IList<PartMorphInfo> morphInfos)
 {
     var count = morphInfos.Any() ? 1.0f / morphInfos.Count() : 1.0f;
     if (part.IsMirrored)
     {
         var verticesDictionary = new Dictionary<uint, Vector3>();
         for (var i = 0; i < part.Points.Count; i++)
         {
             var point = part.Points[i];
             var delta = morphInfos.Aggregate(Vector3.Zero, (current, mi) => current + mi.PointsMorph[i] * mi.Delta) * count;
             foreach (var index in point.Indices)
             {
                 if (!verticesDictionary.ContainsKey(index))
                     verticesDictionary.Add(index, delta);
             }
         }
         for (var i = 0; i < part.Vertices.Length; i++)
         {
             var vertex = part.Vertices[i];
             if (vertex.OriginalPosition.X >= 0.0f && vertex.OriginalPosition.X <= 1.0f)
             {
                 var a = (uint)Math.Abs(vertex.OriginalPosition.Y);
                 var b = (uint)Math.Abs(vertex.OriginalPosition.Z);
                 var point0 = part.BaseVertices[a].Position + verticesDictionary[a];
                 var point1 = part.BaseVertices[b].Position + verticesDictionary[b];
                 vertex.Position = point0 + (point1 - point0) * vertex.OriginalPosition.X;
             }
             else
             {
                 var p = (uint)Math.Abs(vertex.OriginalPosition.X) - 2;
                 var delta = verticesDictionary[p];
                 vertex.Position = part.BaseVertices[p].Position + delta;
                 if (vertex.Position.X > 0.0f == part.IsLeftToRight)
                     vertex.Position.X = 0.0f;
                 if (vertex.OriginalPosition.X < 0.0f)
                     vertex.Position.X *= -1.0f;
             }
             part.Vertices[i] = vertex;
         }
     }
     else
     {
         for (var i = 0; i < part.Points.Count; i++)
         {
             var point = part.Points[i];
             var delta = morphInfos.Aggregate(Vector3.Zero, (current, mi) => current + mi.PointsMorph[i] * mi.Delta) * count;
             foreach (var index in point.Indices)
                 part.Vertices[index].Position = point.Position + delta;
         }
     }
     part.UpdateNormals();
 }

 public static async Task ShowErrorsAsync(IList<string> errors)
 {
     if (errors.Count > 0)
     {
         await ShowErrorAsync(errors.Aggregate((s, next) => s + '\n' + next));
     }
 }

        public static void ModifyFile(string pathToFile, IList<ProjectSolutionMapping> mappings)
        {
            string allText;
            Encoding originalEncoding;
            using (var fileStream = File.OpenText(pathToFile))
            {
                originalEncoding = fileStream.CurrentEncoding;
                allText = fileStream.ReadToEnd();
            }

            if (string.IsNullOrEmpty(allText))
            {
                return;
            }

            if (!AnythingNeedsReplacing(allText, mappings))
            {
                Console.WriteLine(@"nothing to modify in " + pathToFile);
                return;
            }

            Console.WriteLine(@"modifying " + pathToFile);

            allText = mappings.Aggregate(
                allText,
                (current, eachMapping) => current.Replace(eachMapping.OldText, eachMapping.NewText));

            File.WriteAllText(pathToFile, allText, originalEncoding);
        }

 public bool OnActivate(IList<string> args)
 {
     // handle command line arguments of second instance
     Current.MainWindow.Title = args.Any()
                                    ? args.Aggregate((s1, s2) => string.Format("{0}, {1}", s1, s2))
                                    : "Second instance launched";
     return true;
 }

        public CollisionGroup(IList<SimpleSphereCollider> colliders)
        {
            Colliders = colliders;

            _center = colliders.Aggregate(Vector3.zero, (total, each) => (total + each.transform.position)) / colliders.Count;

            _radius = colliders.Select( _=> (_.transform.position - _center).magnitude + _radius ).Max();
        }

 private string AppendMethodParameters(string methodName, IList<string> parameters)
 {
     if (parameters.Count == 0)
     {
         return methodName + "()";
     }
     return methodName + ('(' + parameters.Aggregate((a, b) => a + ", " + b) + ')');
 }

 private static IList<Int32> GenerateSlantingSegmentsRow(IList<Int32> sourceValue, Int32 delta)
 {
     return sourceValue.Aggregate(new List<Int32>(), (acc, value) =>
     {
         acc.AddRange(new[] {value - delta, value + delta});
         return acc;
     });
 }

        private static void StartProcess(IList<string> parameters)
        {
            var process = new Process();

            process.StartInfo.FileName = App.CurrentTranspilerPath;
            process.StartInfo.Arguments = parameters.Aggregate((x, y) => x + " " + y);

            process.Start();
        }

 public ValidateDeploymentUpgradeTypeAttribute()
 {
     this.validValues = new List<string>
     {
         UpgradeType.Auto,
         UpgradeType.Manual,
         UpgradeType.Simultaneous
     };
     commaSeparatedUpgradeTypes = validValues.Aggregate((c, n) => c + ", " + n);
 }

 public static void ShowErrors(IList<string> errors)
 {
     if (errors.Count > 0)
     {
         ShowError(errors.Aggregate((s, next) => s + '\n' + next));
     }
     else
     {
         ShowError("An unknown error has occurred.");
     }
 }

        protected override int performOperation(IList<int> input)
        {
            if (input.Count == 0)
            {
                return 1;
            }
            if (input.Count == 1)
            {
                return input.First();
            }

            return input.Aggregate((a, b) => a * b);
        }

        public static float Run(IList<double> dp0, IList<IList<double>> dpc1)
        {
            IList<LocalPattern> lps1 = new List<LocalPattern>();
            lps1 = dpc1.Aggregate(lps1,
                (current, ts) => current.Concat(GetLocalPatterns(ts, WINDOW_SIZE)).ToList());

            IList<LocalPattern> lps0 = GetLocalPatterns(dp0, WINDOW_SIZE);
            BUCKET_SIZE = (int) (TOP_BUCKET_RATIO*dp0.Count);

            List<List<LocalPatternMatch>> lpmBuckets = GetLocalPatternMatchBuckets(lps0, lps1);

            var allLpms = new List<LocalPatternMatch>();
            foreach (var bucket in lpmBuckets)
            {
                foreach (LocalPatternMatch lpm in bucket)
                {
                    allLpms.Add(lpm);
                }
            }

            int numVertices = allLpms.Count + 2;
            var costMatrix = new int[numVertices, numVertices];

            for (int i = 0; i < allLpms.Count; i++)
            {
                int distToStart = LocalPatternMatch.DistanceToPs(allLpms[i], allLpms.Count, WINDOW_SIZE);
                int distToEnd = LocalPatternMatch.DistanceToPe(allLpms[i], allLpms.Count, WINDOW_SIZE);

                costMatrix[0, i + 1] = distToStart;
                costMatrix[i + 1, numVertices - 1] = distToEnd;
            }

            for (int row = 0; row < numVertices - 2; row++)
            {
                for (int col = 0; col < numVertices - 2; col++)
                {
                    if (row == col)
                        costMatrix[row + 1, col + 1] = 0;
                    else
                        costMatrix[row + 1, col + 1] = LocalPatternMatch.Distance(allLpms[row], allLpms[col],
                            allLpms.Count, WINDOW_SIZE);
                }
            }

            var dijkstra = new Dijkstra.Dijkstra();
            dijkstra.Run(costMatrix, 0);
            return dijkstra.StartToEndDistance;
        }

 public ValidateVMSizeAttribute(bool includeExtraSmall)
 {
     this.validValues = new List<string>
     {
         "Small",
         "Medium",
         "Large",
         "ExtraLarge",
         "A6",
         "A7"
     };
     if (includeExtraSmall)
     {
         this.validValues.Insert(0, "ExtraSmall");
     }
     commaSeparatedVMSizes = validValues.Aggregate((c, n) => c + ", " + n);
 }