populate treeview from a list of path

Question

I'm trying to populate a treeview from a list of folder path, for example:

C:\WINDOWS\addins
C:\WINDOWS\AppPatch
C:\WINDOWS\AppPatch\MUI
C:\WINDOWS\AppPatch\MUI\040C
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI\0409

with an ouput like this:

├───addins
├───AppPatch
│   └───MUI
│       └───040C
├───Microsoft.NET
│   └───Framework
│       └───v2.0.50727
│           └───MUI
│               └───0409

Notice there's no 'C:\WINDOWS\Microsoft.NET' or 'C:\WINDOWS\Microsoft.NET\Framework' in the list. I've been working on this for almost two days and there's a bunch of bug in my code. Hope I can get help from here.

Thanks.

Eric

Same as [this question](http://stackoverflow.com/questions/673931/file-system-treeview/674119#674119) — PaulB, Jul 20 '09 at 21:19
Unless you post the code, its impossible to determine whats wrong with it. Instead of spending days on this why not use a 3rd party control such as the [FolderView](http://www.ssware.com/fldrview.htm) — logicnp, Aug 01 '09 at 16:22

score 30 · Answer 1 · edited Nov 25 '12 at 11:43

private void Form1_Load(object sender, EventArgs e)
    {
        var paths = new List<string>
                        {
                            @"C:\WINDOWS\AppPatch\MUI\040C",
                            @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727",
                            @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI",
                            @"C:\WINDOWS\addins",
                            @"C:\WINDOWS\AppPatch",
                            @"C:\WINDOWS\AppPatch\MUI",
                            @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI\0409"
                        };

        treeView1.PathSeparator = @"\";

        PopulateTreeView(treeView1, paths, '\\');
}


private static void PopulateTreeView(TreeView treeView, IEnumerable<string> paths, char pathSeparator)
    {
        TreeNode lastNode = null;
        string subPathAgg;
        foreach (string path in paths)
        {
            subPathAgg = string.Empty;
            foreach (string subPath in path.Split(pathSeparator))
            {
                subPathAgg += subPath + pathSeparator;
                TreeNode[] nodes = treeView.Nodes.Find(subPathAgg, true);
                if (nodes.Length == 0)
                    if (lastNode == null)
                        lastNode = treeView.Nodes.Add(subPathAgg, subPath);
                    else
                        lastNode = lastNode.Nodes.Add(subPathAgg, subPath);
                else
                    lastNode = nodes[0];
            }
        }
    }

alt text

I tested this approach and it performed poorly with a large tree structure. Suspect it's due to adding each node to the treeview one at a time. I've got nearly 20k paths from our work item management system and this approach ends up throwing ContextSwitchDeadlock exception even when using BeginUpdate. I tested the LINQ approach posted by ykm29 and it finishes processing all 20k nodes in under a second. — GrayDwarf, May 09 '19 at 16:07
The ContextSwitchDeadlock doesn't necessarily mean your code has an issue, just that there is a potential. If you go to Debug > Exceptions in the menu and expand the Managed Debugging Assistants, you will find ContextSwitchDeadlock is enabled. If you disable this, VS will no longer warn you when items are taking a long time to process. In some cases you may validly have a long-running operation. It's also helpful if you are debugging and have stopped on a line while this is processing - you don't want it to complain before you've had a chance to dig into an issue. — ehosca, Jul 09 '19 at 18:35

score 13 · Answer 2 · answered Jul 21 '14 at 09:40

for a linq'y version:

public static TreeNode MakeTreeFromPaths(List<string> paths, string rootNodeName = "", char separator = '/')
{
    var rootNode = new TreeNode(rootNodeName);
    foreach (var path in paths.Where(x => !string.IsNullOrEmpty(x.Trim()))) {
        var currentNode = rootNode;
        var pathItems = path.Split(separator);
        foreach (var item in pathItems) {
            var tmp = currentNode.Nodes.Cast<TreeNode>().Where(x => x.Text.Equals(item));
            currentNode = tmp.Count() > 0 ? tmp.Single() : currentNode.Nodes.Add(item);
        }
    }
    return rootNode;
}

If this ends up duplicating your root node, you can pass in any rootNodeName like "asdf" and then update the return statement to use rootNode.FirstNode. — GrayDwarf, May 09 '19 at 16:50

Sajitha Rathnayake · Answer 3 · 2022-08-30T06:14:32.930

ehosca answer is correcr, but there is a little problem, when I change paths to like this

C:\WINDOWS\AppPatch\MUI\040C
D:\WIS\Microsoft.NET\Framework\v2.0.50727
E:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI
C:\WINDOWS\addins
C:\WINDOWS\AppPatch
C:\WINDOWS\AppPatch\MUI
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI\0409

enter image description here

It will popoulate treeview like this.

But adding some extra code we can avoid this situation. So I changed the code in PopulateTreeView

private static void PopulateTreeView(TreeView treeView, string[] paths, char pathSeparator)
        {
            TreeNode lastNode = null;
            string subPathAgg;
            foreach (string path in paths)
            {
                subPathAgg = string.Empty;
                foreach (string subPath in path.Split(pathSeparator))
                {
                    subPathAgg += subPath + pathSeparator;
                    TreeNode[] nodes = treeView.Nodes.Find(subPathAgg, true);
                    if (nodes.Length == 0)
                        if (lastNode == null)
                            lastNode = treeView.Nodes.Add(subPathAgg, subPath);
                        else
                            lastNode = lastNode.Nodes.Add(subPathAgg, subPath);
                    else
                        lastNode = nodes[0];
                }
                lastNode = null; // This is the place code was changed

            }
        }

Now it works fine like this

enter image description here

I know this was a good, long while ago, but the WinForms implementation of Treeviews is so bad that this was the only code that helped me do what I needed to. I needed checkboxes to populate, so I just threw it another list of paths that I wanted checked, too, and bam! your code worked like a charm. Thanks! — Brian Truman, Sep 15 '20 at 14:33

score 5 · Answer 4 · edited Dec 11 '16 at 00:00

I took your code, and it work very well, but i made just a little modification for improving the load speed when it is used whit a large list of files it seems like find operation, and string operations generally are very slow

private TreeNode PopulateTreeNode2(string[] paths, string pathSeparator)
    {
        if (paths == null)
            return null;

        TreeNode thisnode = new TreeNode();
        TreeNode currentnode;
        char[] cachedpathseparator = pathSeparator.ToCharArray();
        foreach (string path in paths)            {
            currentnode = thisnode;
            foreach (string subPath in path.Split(cachedpathseparator))
            {
                if (null == currentnode.Nodes[subPath])
                    currentnode = currentnode.Nodes.Add(subPath, subPath);
                else
                    currentnode = currentnode.Nodes[subPath];                   
            }
        }

        return thisnode;
    }

then you can use:

string[] paths =  {
                        @"C:\WINDOWS\AppPatch\MUI\040C",
                        @"D:\WINDOWS\Microsoft.NET\Framework\v2.0.50727",
                        @"E:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI",
                        @"C:\WINDOWS\addins",
                        @"C:\WINDOWS\AppPatch",
                        @"C:\WINDOWS\AppPatch\MUI",
                        @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MUI\0409"
                    };
TreeView treeview = new TreeView();
treeview.Nodes.Add(PopulateTreeNode2(paths, "\\"));

~~NOTE: maybe some string sensitivity check will be needed in both solutions, in order to prevent some folders re creations.~~

because some url could be pointing to the same folder on the disk but spelled different such as: Windows ; WinDOWs , WINDOWS

TreeNodeCollection's string indexer internally calls IndexOfKey which does a linear traversal of all child nodes until the key is found followed by IsValidIndex. Find on the other hand is able to control the depth of the search with the searchAllChildren parameter. Depending on the structure of your data you can pick the optimal way. They both end up calling WindowsFormsUtils.SafeCompareStrings in the end. — ehosca, Aug 18 '14 at 20:39

Gumandan · Answer 5 · 2023-08-24T02:08:57.533

I tried ykm29's code but it couldn't properly populate the subfolders. Some other answers here were also using a single path part to identify created TreeNodes. In case there are duplicate folder names in different directories it might cause issues I thought.

So in my code I set "currentPath" value as the Key for TreeNodes i got for folders. "ExtendedFileInfo" in below code extends "FileInfo" class with few additional properties for my own usecase. Before you call this function create your root node and assign it to your TreeView.

private void MakeTreeViewFromPaths(TreeNode rootNode, List<ExtendedFileInfo> files, string rootNodeName = "C:\\", char separator = '\\')
    {
        foreach (var file in files)
        {
            TreeNode currentNode = rootNode;
            string[] relPath = file.RelativePath.Split(separator);
            string currentPath = rootNodeName;  

            //**Split operation always generates an empty entry so we use "-1" to avoid iterating through the last empty array item
            for (int i = 0; i < relPath.Length - 1; i++)
            {
                currentPath += "\\" + relPath[i];
                TreeNode[] tmp = currentNode.Nodes.Find(currentPath, false);
                if (tmp.Length > 0)
                {
                    currentNode = tmp[0];
                    continue;
                }
                //Create Folder Nodes
                currentNode = currentNode.Nodes.Add(currentPath, relPath[i]);
            }

            //Create File Nodes
            TreeNode newNode = new TreeNode(file.FileInfo.Name);
            newNode.Tag = file;
            currentNode.Nodes.Add(newNode);
        }
    }

score 0 · Answer 6 · edited Nov 25 '12 at 11:44

Here's some very old code I once used to create an ASP.NET treeview from code (assuming TreeView has an ID of TreeViewFolders):

protected void Page_Load(object sender, EventArgs e)
{
    GenerateTreeView(@"C:\WINDOWS\");
}

private void GenerateTreeView(string rootPath)
{
    GetFolders(System.IO.Path.GetFullPath(rootPath), TreeViewFolders.Nodes);
    TreeViewFolders.ExpandDepth = 1;
}

// recursive method to load all folders and files into tree
private void GetFolders(string path, TreeNodeCollection nodes)
{
    // add nodes for all directories (folders)
    string[] dirs = Directory.GetDirectories(path);
    foreach (string p in dirs)
    {
        string dp = p.Substring(path.Length);
        nodes.Add(Node("", p.Substring(path.Length), "folder"));
    }

    // add nodes for all files in this directory (folder)
    string[] files = Directory.GetFiles(path, "*.*");
    foreach (string p in files)
    {
        nodes.Add(Node(p, p.Substring(path.Length), "file"));
    }

    // add all subdirectories for each directory (recursive)
    for (int i = 0; i < nodes.Count; i++)
    {
        if (nodes[i].Value == "folder")
            GetFolders(dirs[i] + "\\", nodes[i].ChildNodes);
    }
}

// create a TreeNode from the specified path, text and type
private TreeNode Node(string path, string text, string type)
{
    TreeNode n = new TreeNode();
    n.Value = type;
    n.Text = text;
    return n;
}

score 0 · Answer 7 · edited Mar 13 '18 at 20:52

private void Form2_Load(object sender, EventArgs e)
{
    treeView1.CheckBoxes = true;

    foreach (TreeNode node in treeView1.Nodes)
    {
        node.Checked = true;
    }

    string[] drives = Environment.GetLogicalDrives();

    foreach (string drive in drives)
    {
        // treeView1.Nodes[0].Nodes[1].Checked = true;
        DriveInfo di = new DriveInfo(drive);
        int driveImage;

        switch (di.DriveType)   
        {
            case DriveType.CDRom:
                driveImage = 3;
                break;
            case DriveType.Network:
                driveImage = 6;
                break;
            case DriveType.NoRootDirectory:
                driveImage = 8;
                break;
            case DriveType.Unknown:
                driveImage = 8;
                break;
            default:
                driveImage = 2;
                break;
        }

        TreeNode node = new TreeNode(drive.Substring(0, 1), driveImage, driveImage);
        node.Tag = drive;

        if (di.IsReady == true)
             node.Nodes.Add("...");

        treeView1.Nodes.Add(node);          
    }

    foreach (TreeNode node in treeView1.Nodes)
    {
        node.Checked = true;
    }
}

private void treeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
    {
        if (e.Node.Nodes.Count > 0)
        {
            if (e.Node.Nodes[0].Text == "..." && e.Node.Nodes[0].Tag == null)
            {
                e.Node.Nodes.Clear();

                string[] dirs = Directory.GetDirectories(e.Node.Tag.ToString());

                foreach (string dir in dirs)
                {
                    DirectoryInfo di = new DirectoryInfo(dir);
                    TreeNode node = new TreeNode(di.Name, 0, 1);
                    node.Checked = true;

                    try
                    {
                        node.Tag = dir;
                        if (di.GetDirectories().Count() > 0)
                            node.Nodes.Add(null, "...", 0, 0).Checked = node.Checked;
                    }
                    catch (UnauthorizedAccessException)
                    {
                        node.ImageIndex = 12;
                        node.SelectedImageIndex = 12;
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message, "DirectoryLister", MessageBoxButtons.OK,
                        MessageBoxIcon.Error);
                    }
                    finally
                    {
                        node.Checked = e.Node.Checked;
                        e.Node.Nodes.Add(node);
                    }
                }
            }
        }
    }              
}

private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
{
    button1.Enabled = false;
    TreeNode node = e.Node;
    bool is_checked = node.Checked;
    foreach (TreeNode childNode in e.Node.Nodes)
    {
        childNode.Checked = e.Node.Checked;
    }
    treeView1.SelectedNode = node;
 }

score 0 · Answer 8 · answered Jul 23 '19 at 07:37

I've managed to create a tree from path list using only for cycles. And it looks like it is the simpliest answer of this question at this moment.

Use this block of code to create a tree. list is the list of your files or folders, treeView1 is your TreeView.

//Creates a tree from given path list
foreach (string path in list)
{
    TreeNodeCollection nodes = treeView1.Nodes;

    foreach (string path_part in path.Split('\\'))
    {
        //Here it adds a new node (file or folder)
        if (!nodes.ContainsKey(path_part))
            nodes.Add(path_part, path_part);
        //Go one node deeper
        nodes = nodes[path_part].Nodes;
    }
}

Note - this may break if you use it with paths that start with the path separator (e.g. /home/user)

And if you want to remove common parts of your paths (or remove single parent nodes), use this block of code right after the previous one:

//This removes "single" TreeNodes (common paths)
while (treeView1.Nodes.Count == 1)
{
    //This "unpacks" child TreeNodes from the only parent TreeNode
    for (int i = 0; i < treeView1.Nodes[0].Nodes.Count; i++)
        treeView1.Nodes.Add(treeView1.Nodes[0].Nodes[i]);
    //This removes parent TreeNode
    treeView1.Nodes.RemoveAt(0);
}

This will generate an empty tree if all of your paths are the same.

populate treeview from a list of path

8 Answers8

Linked