C# Task.Sum方法代码示例

 public int GetAsyncCallbackData(int value, int asyncCallbacksToMake)
 {
     int result = value;
     var tasks = new Task<int>[asyncCallbacksToMake];
     for (int i = 0; i < asyncCallbacksToMake; i++)
     {
         tasks[i] = OperationContext.Current.GetCallbackChannel<IDuplexCallback>().EchoGetAsyncCallbackData(result + i);
     }
     Task.WhenAll(tasks).Wait();
     result = tasks.Sum((t) => t.Result);
     return result;
 }

        public static float Sum(float[] values, Func<float, float> selector, int threadsCount)
        {
            if (threadsCount < 2 || values.Length <= threadsCount)
                return selector == null ? values.Sum() : values.Sum(selector);

            Task<float>[] tasks = new Task<float>[threadsCount];
            int chunk = (int)Math.Ceiling((double)values.Length/threadsCount);
            for (int i = 0; i < threadsCount; i++)
            {
                int start = i*chunk;
                int end = Math.Min(start + chunk, values.Length);
                tasks[i] = Task.Run(() => Sum(values, selector, start, end));
            }

            return tasks.Sum(t => t.Result);
        }

        public static PerformanceResult RunConcurrentPerformanceTest(int numIterations, int degreeParallelism,
            Action operation)
        {
            int i;
            var taskList = new Task<PerformanceResult>[degreeParallelism];
            long startTime = HiResTimer.Ticks;
            int subIterations = numIterations/degreeParallelism;

            for (i = 0; i < degreeParallelism; i++)
            {
                var t = new Task<PerformanceResult>(() => RunPerformanceTest(subIterations, operation, true));
                taskList[i] = t;
            }

            for (i = 0; i < degreeParallelism; i++) taskList[i].Start();

            Task.WaitAll(taskList);
            long stopTime = HiResTimer.Ticks;

            var rawData = new List<double>();

            for (i = 0; i < degreeParallelism; i++)
            {
                rawData.AddRange(taskList[i].Result.DescriptiveResult.RawData);
            }

            var desc = new DescriptiveAnalysis(rawData);
            desc.Analyze(false);
            desc.AnalyzeHistogram(cHistogramBuckets);

            var res = new PerformanceResult
            {
                IsValid = true,
                Iterations = taskList.Sum(p => p.Result.Iterations),
                DegreeOfParallelism = degreeParallelism,
                TotalMilliseconds = ConvertToMs(startTime, stopTime),
                TotalSeconds = ConvertToSeconds(startTime, stopTime),
                TotalTicks = stopTime - startTime,
                DescriptiveResult = desc.Result
            };

            for (i = 0; i < degreeParallelism; i++) taskList[i].Dispose();

            return res;
        }

	    /// <summary>
	    /// Executes each <see cref="Searchable"/>'s docFreq() in its own thread and 
	    /// waits for each search to complete and merge the results back together.
	    /// </summary>
		public override int DocFreq(Term term)
	    {
	        Task<int>[] tasks = new Task<int>[searchables.Length];
            for (int i = 0; i < searchables.Length; i++)
            {
                Searchable searchable = searchables[i];
                tasks[i] = Task.Factory.StartNew(() => searchable.DocFreq(term));
            }

	        Task.WaitAll(tasks);
	        return tasks.Sum(task => task.Result);
	    }

        private static double CalculateIntegral(Calculator calc, Func<Calculator, double> distanceMethod, double leftBound, double rightBound)
        {
            // Protip: the Wolfram Alpha way of verifying the results from this is:
            // "integral of (<<top>> - <<bottom>>)dx between <<start>> and <<stop>>"

            int numCores = Environment.ProcessorCount;

            int iterCount = (int)Math.Ceiling((rightBound - leftBound) / Increment);
            int itersPerCore = (int)Math.Floor((double)iterCount / numCores);

            // The number of iterations that the last thread should do (to accomodate for rounding errors)
            int lastCoreIters = itersPerCore + (iterCount % numCores);

            // Assemble the worker threads
            Task<double>[] tasks = new Task<double>[numCores];
            int core = 0;

            bool lastTask = false;
            while (!lastTask)
            {
                lastTask = core + 1 >= numCores;

                double start = leftBound + ((core * itersPerCore) * Increment);
                int numIters = (lastTask ? lastCoreIters : itersPerCore);

                tasks[core++] = new Task<double>(() => CalculateAreaChunk(new Calculator(calc), distanceMethod, start, rightBound, numIters));
            }

            foreach (Task<double> t in tasks)
            {
                t.Start();
            }

            Task.WaitAll(tasks);

            double totalArea = tasks.Sum(t => t.Result);

            // Find the number of decimal places the increment goes to
            int decPlace = 0;
            double slicedIncrement = Increment;

            // Move the decimal point of the increment to the right on each iteration. We keep
            // moving the decimal over until the first significant digit of the increment is found
            while ((int)(slicedIncrement *= 10) == 0)
            {
                decPlace++;
            }

            // Assume the area is only accurate to the number of decimal places that the increment has
            return Math.Round(totalArea, decPlace + 1);
        }