C# Queue.EnqueueRange方法代码示例

        private object GetSubPageActive()
        {
            if (this.BookPage.SubPages == null)
            {
                return false;
            }

            // If this page is active, then no sub pages are active.
            //
            if (this.BookPage.Document == this.ActiveDocument)
            {
                return false;
            }

            var pages = new Queue<BookPage>(this.BookPage.SubPages);

            while (pages.Count > 0)
            {
                var page = pages.Dequeue();

                if (page.Document == this.ActiveDocument)
                {
                    return true;
                }

                if (page.SubPages != null)
                {
                    pages.EnqueueRange(page.SubPages);
                }
            }

            return false;
        }

 public override ExecutionEnvironment Compile(string source, string input)
 {
     var inputQ = new Queue<BigInteger>();
     switch (_settings.InputType)
     {
         case IOType.Numbers: try
             {
                 inputQ.EnqueueRange(input.Split(',').Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => BigInteger.Parse(s)));
             }
             catch (FormatException)
             {
                 throw new Exception("Please provide the input as a comma-separated sequence of integers (or change the semantics in the Semantics menu).");
             }
             break;
         case IOType.Characters:
             inputQ.EnqueueRange(input.Select(ch => (BigInteger) (int) ch));
             break;
         default:
             throw new InvalidOperationException();
     }
     return BrainfuckEnv.GetEnvironment(_settings.CellType, source, inputQ, _settings.OutputType);
 }

        void featuresTree_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (isAutoCheckingActive)
            {
                isAutoCheckingActive = false;
                bool newState = e.Node.Checked;
                var queue = new Queue<TreeNode>();
                queue.EnqueueRange(e.Node.Nodes.ToArray());

                while (queue.Any())
                {
                    var node = queue.Dequeue();
                    node.Checked = newState;
                    queue.EnqueueRange(node.Nodes.ToArray());

                }
                isAutoCheckingActive = true;
            }
        }

        public IEnumerable<SourceFile> AllContributingFiles()
        {
            var set = new HashSet<SourceFile>();

            var all = new Queue<SourceFile>(this.ContributingFiles);

            while (all.Count > 0)
            {
                var file = all.Dequeue();

                if (set.Add(file))
                {
                    all.EnqueueRange(file.ContributingFiles);
                }
            }

            return set;
        }

 public IEnumerable<GridCell> GetPlaceholderCells()
 {
     var result = new List<GridCell>();
     var rows = new Queue<GridRow>();
     rows.EnqueueRange(_rows);
     while (rows.Count > 0)
     {
         var row = rows.Dequeue();
         foreach (var cell in row.Cells)
         {
             if (cell.Type == GridLayoutCellType.Placeholder)
                 result.Add(cell);
             else if (cell.Type == GridLayoutCellType.InnerGrid)
             {
                 var grid = (GridLayout) cell;
                 rows.EnqueueRange(grid.Rows);
             }
         }
     }
     return result;
 }

 public void RebuildSearchIndex()
 {
     using (var service = new CrawlService("site"))
     {
         service.ClearDatabase();
     }
     Queue<Page> pages = new Queue<Page>();
     using (CmsContext.Published)
     {
         var siteRoots = CmsService.Instance.SelectItems<SiteRoot>("/Content/*/*{SiteRoot}");
         pages.EnqueueRange(siteRoots.SelectMany(r => r.GetChildren<Page>()));
         while (pages.Count > 0)
         {
             var page = pages.Dequeue();
             if (page.Template.Path.StartsWith("/WebPage"))
             {
                 var site = CmsService.Instance.GetSitePath(page.Path).Split('/').Last();
                 var thumbnail = page.GetValue<Image>("thumbnail");
                 SearchBackgroundCrawler.QueueDocumentAdd(site, page, thumbnail.Exists ? thumbnail.Url : string.Empty);
             }
             pages.EnqueueRange(page.GetChildren<Page>());
         }
     }
 }

        private static IEnumerable<BookPage> AllChapters(Book book)
        {
            var queue = new Queue<BookPage>(book.Chapters);

            while (queue.Count > 0)
            {
                var page = queue.Dequeue();

                if (page.Chapter)
                {
                    queue.EnqueueRange(page.SubPages);

                    yield return page;
                }
            }
        }