C# TreeItem类代码示例

 public void TreePrint(TreeItem treeItem)
 {
     foreach (var item in treeItem.SubItems.OrderBy(x => x.Order))
     {
         ChildPrint(item, 0);
     }
 }

        private static void PopulateFolders(string dirName, TreeItem<string> parentFolder)
        {
            string[] folderItems = Directory.GetFileSystemEntries(dirName);

            foreach (var folderItem in folderItems)
            {
                TreeItem<string> folderSubItem = new TreeItem<string>(folderItem);
                parentFolder.AddChild(folderSubItem);

                // If the current node is a filename, don't call recursion and continue
                try
                {
                    Directory.GetDirectories(folderItem);
                }
                catch (IOException ex)
                {
                    continue;
                }
                catch (UnauthorizedAccessException)
                {
                    Console.WriteLine("LOG: No access to folder {0}", dirName);
                    continue;
                }

                PopulateFolders(folderItem, folderSubItem);
            }
        }

 public TreeItem GenerateTteeVm(int col, int depth, string version)
 {
     OrderInc = 0;
     var item = new TreeItem() { Name = "root " + version };
     item.SubItems = GenerateTteeItemList(col, depth,version);
     return item;
 }

 private void GenerateTree(TreeItem<FileSystemItem> node, int depth, int level = 0)
 {
     var itemCount = C.Random<int>(_fakingRules.GetItemCount(level));
     var nodes = node.AddRange(C.CollectionOfFake<FileSystemItem>(itemCount, new { Type = _fakingRules.GetItemTypes(level), Name = new Range(8,13) }));
     foreach (var n in nodes)
     {
         n.Content.FullPath = n.Content.Path = node.Content.Path + "/" + n.Content.Name;
         n.Content.Size = C.Random<int>(0xFF, 0xFFFF);
         if (level < depth) GenerateTree(n, depth, level+1);
     }
 }

		public TreeItem (TreeStore store, TreeItem parent, CoverageItem model, string title) {
			this.store = store;
			this.parent = parent;
			this.model = model;

			if (parent == null)
				iter = store.AppendValues (title);
			else
				iter = store.AppendValues (parent.Iter, title);
			FillColumns ();
		}

        public TreeEntryMenu(ITreeSource treeSource, TreeItem treeItem)
        {
            if(treeSource == null) throw new ArgumentNullException("treeSource");
            if(treeItem == null) throw new ArgumentNullException("treeItem");

            _treeSource = treeSource;
            _treeItem = treeItem;

            // save as
            // checkout

            Items.Add(GuiItemFactory.GetCheckoutPathItem<ToolStripMenuItem>(treeSource, treeItem.RelativePath));
        }

 public void WriteTree(Guid versionId, TreeItem item)
 {
     OrderInc = 0;
     //            using (var context = _context)
     {
         //foreach (var element in item.SubItems.OrderBy(x => x.Order))
         {
             var root = Dive(item, null, versionId);
             HierarchyParentChildContext.Elements.Add(root);
             HierarchyParentChildContext.SaveChanges();
         }
     }
 }

 TreeItem CreateTreeItem(int level, string name, Image image)
 {
     var item = new TreeItem {
         Text = name,
         Expanded = expanded++ % 2 == 0,
         Image = image
     };
     if (level < 4) {
         for (int i = 0; i < 4; i++) {
             item.Children.Add (CreateTreeItem (level + 1, name + " " + i, image));
         }
     }
     return item;
 }

        public UnstagedItemMenu(TreeItem item)
        {
            Verify.Argument.IsValidGitObject(item, "item");
            Verify.Argument.AreEqual(StagedStatus.Unstaged, item.StagedStatus & StagedStatus.Unstaged, "item",
                "This item is not unstaged.");

            _item = item;

            var dir = _item as TreeDirectory;
            if(_item.Status != FileStatus.Removed)
            {
                var fullPath = _item.FullPath;
                if(dir == null)
                {
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpen, null, fullPath));
                    Items.Add(GuiItemFactory.GetOpenUrlWithItem<ToolStripMenuItem>(Resources.StrOpenWith.AddEllipsis(), null, fullPath));
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpenContainingFolder, null, Path.GetDirectoryName(fullPath)));
                }
                else
                {
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpenInWindowsExplorer, null, fullPath));
                }
                Items.Add(new ToolStripSeparator());
            }
            Items.Add(GuiItemFactory.GetStageItem<ToolStripMenuItem>(_item));
            if(dir != null)
            {
                if(HasRevertableItems(dir))
                {
                    Items.Add(GuiItemFactory.GetRevertPathItem<ToolStripMenuItem>(_item));
                }
            }
            else
            {
                if(_item.Status == FileStatus.Removed || _item.Status == FileStatus.Modified)
                {
                    Items.Add(GuiItemFactory.GetRevertPathItem<ToolStripMenuItem>(_item));
                }
                if(_item.Status == FileStatus.Modified || _item.Status == FileStatus.Added)
                {
                    Items.Add(GuiItemFactory.GetRemovePathItem<ToolStripMenuItem>(_item));
                }
            }
        }

        private static void FindExeFile(List<string> foundExeFiles, TreeItem<string> treeItem)
        {
            string pattern = "exe";

            if (!treeItem.IsFolder)
            {
                string[] fileParts = treeItem.Value.Split('.');

                if (fileParts[fileParts.Length - 1] == pattern)
                {
                    foundExeFiles.Add(treeItem.Value);
                }
            }

            for (int i = 0; i < treeItem.ChildItemsCount; i++)
            {
                FindExeFile(foundExeFiles, treeItem.GetChild(i));
            }
        }

        public void Index_GET()
        {
            IList<SiteDto> sites=SiteCacheManager.GetAllSites();
            TreeItem[] items=new TreeItem[sites.Count];
            for (int i = 0; i < sites.Count; i++)
            {
                items[i] = new TreeItem
                {
                    ID=sites[i].SiteId,
                    Name=sites[i].Name + (sites[i].Note.Trim()!=""?"["+sites[i].Note+"]":"")
                };
            }


            base.RenderTemplate(ResourceMap.GetPageContent(ManagementPage.Site_Index), new
            {
                siteTree=Helper.SingleTree("所有站点",items)
            });
        }

		public UserList (Channel channel)
		{
			this.Channel = channel;
			tree = new TreeView ();
			tree.Style = "userList";
			tree.Activated += HandleActivated;
			
			items = new TreeItemCollection ();
			items.Add (owners = new TreeItem { Text = "Room Owners", Expanded = true });
			items.Add (online = new TreeItem { Text = "Online", Expanded = true });
			items.Add (away = new TreeItem { Text = "Away", Expanded = true });
			if (Generator.ID == Generators.Mac) {
				foreach (var item in items.OfType<TreeItem>()) {
					item.Text = item.Text.ToUpperInvariant();
				}
			}
			tree.DataStore = items;
			
			this.AddDockedControl (tree);
		}

        static void Main(string[] args)
        {
            string rootDirectory = @"C:\Windows";

            TreeItem<string> rootFolder = new TreeItem<string>(rootDirectory);

            Console.WriteLine("Getting items in {0}, this can take a while", rootDirectory);
            Console.WriteLine();

            PopulateFolders(rootDirectory, rootFolder);

            Tree<string> foldersTree = new Tree<string>(rootFolder);

            List<string> exeFiles = new List<string>();

            FindExeFile(exeFiles, foldersTree.Root);

            Console.WriteLine();
            Console.WriteLine("Found {0} .exe files", exeFiles.Count);
        }

      /// <summary>
      /// Expands the root tree item to the currently selected item.
      /// </summary>
      /// <param name="iRoot">Root tree item.</param>
      private void ExpandToSelection(ref TreeItem iRoot)
      {
         if (iRoot == null || SelectedId == 0 || SelectedId == iRoot.Id)
            return;

         var treeItem = LoadTreeItem(SelectedId);

         var records = EmployeeModel.AllRecords;
         var record = records.FirstOrDefault(i => i.Id == SelectedId);
         var reportToId = record.ReportTo;

         // Start from the selected item and work our way up until the root is reached.
         while (reportToId != iRoot.Id && (record = records.FirstOrDefault(i => i.Id == reportToId)) != null)
         {
            var parentItem = LoadTreeItem(record.Id);
            parentItem.Children[parentItem.Children.FindIndex(i => i.Id == treeItem.Id)] = treeItem;
            reportToId = record.ReportTo;
            treeItem = parentItem;
         }
         iRoot.Children[iRoot.Children.FindIndex(i => i.Id == treeItem.Id)] = treeItem;
      }

 private static Result CompareTrees(TreeItem tree1, TreeItem tree2)
 {
     if (tree1.Name != tree2.Name) return new Result(false, tree1, tree2);
     if (tree1.Order != tree2.Order) return new Result(false, tree1, tree2);
     if (tree1.SubItems == null)
     {
         if (tree2.SubItems != null) return new Result(false, tree1, tree2);
         if (tree1.Placeholder != tree2.Placeholder) return new Result(false, tree1, tree2);
     }
     else
     {
         if (tree2.SubItems == null) return new Result(false, tree1, tree2);
         if (tree1.SubItems.Count != tree2.SubItems.Count) return new Result(false, tree1, tree2);
         for (int i = 0; i < tree1.SubItems.Count; i++)
         {
             var r = CompareTrees(tree1.SubItems[i], tree2.SubItems[i]);
             if (!r.Equals) return r;
         }
     }
     return new Result(true, null, null);
 }