C# BlockingCollection.ToList方法代码示例

        public void DetachedParentChild()
        {
            //Arrange
              var sequence = new BlockingCollection<int>();
              var child1 = new Action(() => { sequence.Add(2); Thread.Sleep(5000); sequence.Add(4); });
              var parent = new Action(() => { sequence.Add(1); Task.Factory.StartNew(child1); Thread.Sleep(2500); sequence.Add(3); });

              //Act
              var parent_task = Task.Factory.StartNew(parent);
              parent_task.Wait();

              //Assert
              Assert.IsTrue(Enumerable.SequenceEqual(new int[] { 1, 2, 3 }, sequence), sequence.Aggregate(new StringBuilder(), (whole, next) => whole.AppendFormat("{0}|", next)).ToString());
              CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, sequence.ToList());
        }

        public static List<Builder> LoadBuildersInParallel(int numberOfBuilders)
        {
            BlockingCollection<Builder> buildersToLoad = new BlockingCollection<Builder>();
            BlockingCollection<Builder> loadedBuilders = new BlockingCollection<Builder>();

            for (int i = 0; i < numberOfBuilders; i++)
            {
                buildersToLoad.Add(new Builder { Name = "Builder" + i, Status = "Status" + i });
            }

            Parallel.ForEach(buildersToLoad, new ParallelOptions { MaxDegreeOfParallelism = 100 }, currentBuilder =>
            {
              //database load/instansiation of objects
               Thread.Sleep(1000);
                loadedBuilders.Add(currentBuilder);
            });

            return loadedBuilders.ToList();
        }

        public List<int> Execute(int minPrime, int maxPrime, int degree)
        {
            _primes = new BlockingCollection<int> {2, 3, 5, 7};
            _candidates = new BlockingCollection<int>();
            var subTasks = new Task[degree];

            for (int i = 0; i < degree; i++)
            {
                subTasks[i] = new Task(() => SubTask(_candidates, _primes));
                subTasks[i].Start();
            }

            for (int c = 8; c < maxPrime; c++) _candidates.Add(c);
            _candidates.CompleteAdding();

            Task.WaitAll(subTasks);

            return _primes.ToList();
        }

 private static List<FileInfo> GetFilesContainesStringParallel(List<FileInfo> filesList, string str)
 {
     Console.ForegroundColor = ConsoleColor.Magenta;
     Stopwatch leadTime = Stopwatch.StartNew();
     BlockingCollection<FileInfo> filesThatContainedString = new BlockingCollection<FileInfo>();
     ParallelLoopResult loopResult = Parallel.ForEach(filesList, (file) =>
     {
         if (FindString(file, str)) filesThatContainedString.Add(file);
     });
     if (!loopResult.IsCompleted)
     {
         Console.WriteLine("Fail on iteration " + loopResult.LowestBreakIteration + "\n");
     }
     leadTime.Stop();
     Console.WriteLine("GetFilesContainesStringParallel() leadTime: {0} ms", leadTime.ElapsedMilliseconds);
     Console.ForegroundColor = ConsoleColor.White;
     return filesThatContainedString.ToList();
 }

        public static List<Builder> LoadBuildersWithTasks(int numberOfBuilders)
        {
            BlockingCollection<Builder> buildersToLoad = new BlockingCollection<Builder>();
            BlockingCollection<Builder> loadedBuilders = new BlockingCollection<Builder>();

            for (int i = 0; i < numberOfBuilders; i++)
            {
                buildersToLoad.Add(new Builder { Name = "Builder" + i, Status = "Status" + i });
            }
            buildersToLoad.CompleteAdding();

            Task loader1 = Task.Factory.StartNew(() =>
                {
                    foreach (Builder item in buildersToLoad.GetConsumingEnumerable())
                    {
                        Thread.Sleep(1000);
                        loadedBuilders.Add(item);
                    }
                }, TaskCreationOptions.LongRunning);

            Task loader2 = Task.Factory.StartNew(() =>
            {
                foreach (Builder item in buildersToLoad.GetConsumingEnumerable())
                {
                    Thread.Sleep(1000);
                    loadedBuilders.Add(item);
                }
            }, TaskCreationOptions.LongRunning);

            Task.WaitAll(loader1, loader2);
            return loadedBuilders.ToList();
        }

         //<summary>
         //Gets the list of all partitions that have pending unpublished events.
         //</summary>
         //<returns>The list of all partitions.</returns>
        public IEnumerable<string> GetPartitionsWithPendingEvents()
        {
            var eventTableServiceEntities = new TableQuery<EventTableServiceEntity>();
            var table = this.tableClient.GetTableReference(this.tableName);

            var query = new TableQuery<EventTableServiceEntity>()
                //.Where(
                //TableQuery.CombineFilters(
                //    TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, UnpublishedRowKeyPrefix),
                //    TableOperators.And,
                //    TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, UnpublishedRowKeyPrefixUpperLimit)))
                   // .Select(x => new { x.PartitionKey })
                    .AsTableQuery();

            //var query = eventTableServiceEntities
            //    .Where(
            //        x =>
            //        String.Compare(x.RowKey, UnpublishedRowKeyPrefix, StringComparison.Ordinal) >= 0 &&
            //        String.Compare(x.RowKey, UnpublishedRowKeyPrefixUpperLimit, StringComparison.Ordinal) <= 0)
            //    .Select(x => new { x.PartitionKey });


            var result = new BlockingCollection<string>();
            
            var continuationToken = new TableContinuationToken();
            var queryResult = table.ExecuteQuerySegmentedAsync(query, continuationToken).Result;
            foreach (var key in queryResult.Results.Select(x => x.PartitionKey).Distinct())
            {
                result.Add(key);
            }

            return result.ToList();
        }