C# (CSharp) ConcurrentQueue.Aggregate示例

示例#1

            public T Resolve()
            {
                var instance = originalRegistration(container);

                var transformed = (T)Transforms.Aggregate(instance,
                                                          (current, transform) => transform(container, (T)current));

                return(transformed);
            }

示例#2

        public IEnumerable <CommandResult> Run(CloudTable table, int numberOfProcess, int parallelism = 0)
        {
            if (parallelism == 0)
            {
                parallelism = System.Environment.ProcessorCount * 3;
            }

            if (parallelism == 1)
            {
                return(Run(table, new Tuple <int, int>(0, numberOfProcess)));
            }

            var sizeOfWorkload = numberOfProcess / parallelism + (numberOfProcess % parallelism == 0 ? 0 : 1);

            var chunker = Partitioner.Create(0, numberOfProcess, sizeOfWorkload);

            var results = new ConcurrentQueue <IList <CommandResult> >();

            // Loop over the workload partitions in parallel.
            Parallel.ForEach(chunker,
                             new ParallelOptions {
                MaxDegreeOfParallelism = parallelism
            },
                             (range) => results.Enqueue(Run(table, range))
                             );

            var ret = new List <CommandResult>();

            foreach (var l in results)
            {
                ret.AddRange(l);
            }

            return(ret);

#if BUG
            return(results.Aggregate <IEnumerable <CommandResult> >((f, s) =>
            {
                return f.Concat(s).AsEnumerable();
            }));
#endif
        }

示例#3

文件： SizeLimitedConcurrentSet.cs 项目： ybdev/ravendb

 public TAccumolate Aggregate <TAccumolate>(TAccumolate seed, Func <TAccumolate, T, TAccumolate> aggregate)
 {
     return(queue.Aggregate(seed, aggregate));
 }

示例#4

文件： InsertBatch.cs 项目： takekazuomi/WAAC201202

        public IEnumerable<CommandResult> Run(CloudTable table, int numberOfProcess, int parallelism = 0)
        {
            if (parallelism == 0) parallelism = System.Environment.ProcessorCount * 3;

            if(parallelism == 1)
                return Run(table, new Tuple<int, int>(0, numberOfProcess));

            var sizeOfWorkload = numberOfProcess / parallelism + (numberOfProcess % parallelism == 0 ? 0 : 1);

            var chunker = Partitioner.Create(0, numberOfProcess, sizeOfWorkload);

            var results = new ConcurrentQueue<IList<CommandResult>>();

            // Loop over the workload partitions in parallel.
            Parallel.ForEach(chunker,
                new ParallelOptions { MaxDegreeOfParallelism = parallelism },
                (range) => results.Enqueue(Run(table, range))
                );

            var ret = new List<CommandResult>();

            foreach (var l in results) ret.AddRange(l);

            return ret;
#if BUG
            return results.Aggregate<IEnumerable<CommandResult>>((f, s) =>
            {
                return f.Concat(s).AsEnumerable();
            });
#endif
        }