我是新与节点这里.. :)我想出了这个算法，但它只能说明..父节点列表这样的..

  A
   a.txt中
   b
   C
C
   米
   ñ
b
   Ø
   p
等等...
 

我想下一个节点将被放在previous节点内的节点之一..所以它会想出这样的..

  A
   a.txt中
   b
      Ø
      p
   C
      米
      ñ
等等...
 

我有一些想法在脑海，但我可以把它落实codeS .. :)任何帮助，请..

 私人无效ListDirectory（TreeView的树视图，字符串路径）
{
    堆叠＆LT;字符串＆GT;堆栈=新的堆栈＆LT;字符串＆GT;（）;
    树节点DirFilesCollection =新的TreeNode（）;

    stack.Push（路径）;

    而（stack.Count大于0）
    {
        字符串DIR = stack.Pop（）;
        尝试
        {
            名单＆LT;字符串＆GT; parentDir =新的名单，其中，串＆GT;（）;
            parentDir.AddRange（Directory.GetFiles（目录，）*。*）;
            parentDir.AddRange（Directory.GetDirectories（目录））;

            DirectoryInfo的D =新的DirectoryInfo（目录）;
            树节点TParent =新的TreeNode（d.Name）;

            的foreach（字符串S在parentDir）
            {
                FileInfo的F =新的FileInfo（S）;
                树节点子项目=新的TreeNode（f.Name）;

                TParent.Nodes.Add（子项目）;
            }

            DirFilesCollection.Nodes.Add（TParent）;

            的foreach（在Directory.GetDirectories字符串DN（DIR））
            {
                stack.Push（DN）;
            }
        }
        抓住
        {}
    }

    行动clearTreeView =（）=＆GT; treeView.Nodes.Clear（）;
    this.Invoke（clearTreeView）;

    行动showTreeView =（）=＆GT; treeView.Nodes.Add（DirFilesCollection）;
    this.Invoke（showTreeView）;
}
 

解决方案

选项＃1：递归的方式：

 私人无效ListDirectory（TreeView的树视图，路径字符串）
{
    treeView.Nodes.Clear（）;
    VAR rootDirectoryInfo =新的DirectoryInfo（路径）;
    treeView.Nodes.Add（CreateDirectoryNode（rootDirectoryInfo））;
}

私有静态树节点CreateDirectoryNode（DirectoryInfo的DirectoryInfo的）
{
    VAR directoryNode =新的TreeNode（directoryInfo.Name）;
    的foreach（VAR在directoryInfo.GetDirectories）目录（）
        directoryNode.Nodes.Add（CreateDirectoryNode（目录））;
    的foreach（在directoryInfo.GetFiles var文件（））
        directoryNode.Nodes.Add（新的TreeNode（file.Name））;
    返回directoryNode;
}
 

选项＃2：非递归的方式：

 私有静态无效ListDirectory（TreeView的树视图，路径字符串）
{
    treeView.Nodes.Clear（）;

    VAR堆栈=新的堆栈＆LT;树节点＆GT;（）;
    VAR rootDirectory =新的DirectoryInfo（路径）;
    VAR节点=新的TreeNode（rootDirectory.Name）{标签= rootDirectory};
    stack.Push（节点）;

    而（stack.Count大于0）
    {
        变种currentNode = stack.Pop（）;
        VAR的DirectoryInfo =（DirectoryInfo的）currentNode.Tag;
        的foreach（VAR在directoryInfo.GetDirectories）目录（）
        {
            VAR childDirectoryNode =新的TreeNode（directory.Name）{标签=目录};
            currentNode.Nodes.Add（childDirectoryNode）;
            stack.Push（childDirectoryNode）;
        }
        的foreach（在directoryInfo.GetFiles var文件（））
            currentNode.Nodes.Add（新的TreeNode（file.Name））;
    }

    treeView.Nodes.Add（节点）;
}
 

i am new with Nodes here.. :) i came up with this algorithm but it only shows the list of parent nodes.. like this..

a
   a.txt
   b
   c
c
   m
   n
b
   o
   p
etc...

i want the next node will be put in one of the node inside the previous node.. so it will come up like this..

a
   a.txt
   b
      o
      p
   c
      m
      n
etc...

i have some ideas in mind but i can implement it to codes.. :) any help please..

private void ListDirectory(TreeView treeView, String path)
{            
    Stack<string> stack = new Stack<string>();
    TreeNode DirFilesCollection = new TreeNode();

    stack.Push(path);            

    while (stack.Count > 0)
    {
        string dir = stack.Pop();
        try
        {
            List<String> parentDir = new List<string>();
            parentDir.AddRange(Directory.GetFiles(dir, "*.*"));
            parentDir.AddRange(Directory.GetDirectories(dir));

            DirectoryInfo d = new DirectoryInfo(dir);
            TreeNode TParent = new TreeNode(d.Name);

            foreach (String s in parentDir)
            {
                FileInfo f = new FileInfo(s);
                TreeNode subItems = new TreeNode(f.Name);

                TParent.Nodes.Add(subItems);
            }

            DirFilesCollection.Nodes.Add(TParent);

            foreach (string dn in Directory.GetDirectories(dir))
            {
                stack.Push(dn);
            }
        }
        catch
        {}
    }

    Action clearTreeView = () => treeView.Nodes.Clear();
    this.Invoke(clearTreeView);

    Action showTreeView = () => treeView.Nodes.Add(DirFilesCollection);
    this.Invoke(showTreeView);
}

Option #1: Recursive approach:

private void ListDirectory(TreeView treeView, string path)
{
    treeView.Nodes.Clear();
    var rootDirectoryInfo = new DirectoryInfo(path);
    treeView.Nodes.Add(CreateDirectoryNode(rootDirectoryInfo));
}

private static TreeNode CreateDirectoryNode(DirectoryInfo directoryInfo)
{
    var directoryNode = new TreeNode(directoryInfo.Name);
    foreach (var directory in directoryInfo.GetDirectories())
        directoryNode.Nodes.Add(CreateDirectoryNode(directory));
    foreach (var file in directoryInfo.GetFiles())
        directoryNode.Nodes.Add(new TreeNode(file.Name));
    return directoryNode;
}

Option #2: Non-recursive approach:

private static void ListDirectory(TreeView treeView, string path)
{
    treeView.Nodes.Clear();

    var stack = new Stack<TreeNode>();
    var rootDirectory = new DirectoryInfo(path);
    var node = new TreeNode(rootDirectory.Name) { Tag = rootDirectory };
    stack.Push(node);

    while (stack.Count > 0)
    {
        var currentNode = stack.Pop();
        var directoryInfo = (DirectoryInfo)currentNode.Tag;
        foreach (var directory in directoryInfo.GetDirectories())
        {
            var childDirectoryNode = new TreeNode(directory.Name) { Tag = directory };
            currentNode.Nodes.Add(childDirectoryNode);
            stack.Push(childDirectoryNode);
        }
        foreach (var file in directoryInfo.GetFiles())
            currentNode.Nodes.Add(new TreeNode(file.Name));
    }

    treeView.Nodes.Add(node);
}