Using BeginInvoke in a recursive function adding nodes to a TreeView in a BackgroundWorker

Question

My code has a function that scans a root directory and showing txt files (for example) in a TreeView:

private TreeNode DirectoryToTreeView(TreeNode parentNode, string path,
                                     string extension = ".txt")
{
    var result = new TreeNode(parentNode == null ? path : Path.GetFileName(path));
    foreach (var dir in Directory.GetDirectories(path))
    {
        TreeNode node = DirectoryToTreeView(result, dir);
        if (node.Nodes.Count > 0)
        {
            result.Nodes.Add(node);
        }
    }
    foreach (var file in Directory.GetFiles(path))
    {
        if (Path.GetExtension(file).ToLower() == extension.ToLower())
        {
            result.Nodes.Add(Path.GetFileName(file));
        }
    }
    return result;
}

This function should by called from the button like: treeView1.Nodes.Add(DirectoryToTreeView(null, @"C:\Users\Tomer\Desktop\a")); Its obviously freezing the UI. I am new to this and I have searched the web and nothing seemed relevant to my problem because no one used recursive function and I cant simply call BeginInvoke on the entire function because it will have no effect. What path should I take? Maybe change the function to work with a while loop and then calling BeginInvoke inside the if statements? Creating a TreeNode object in memory to populate (which may be too large)?

Answer 1

Here's an example for async Task method to populate a TreeNode with a directory-tree for a given file type. The inner CreateTree(...) is a local function called recursively to traverse the directories.

private async Task<TreeNode> CreateTreeAsync(string startDir, string fileExt)
{
    var di = new DirectoryInfo(startDir);
    var result = new TreeNode(di.Name);
    var searchPattern = $"*.{fileExt.TrimStart('.')}";

    return await Task.Run(() =>
    {
        void CreateTree(DirectoryInfo dirInfo, TreeNode node)
        {
            try
            {
                foreach (var fileInfo in dirInfo.EnumerateFiles(searchPattern))
                    node.Nodes.Add(fileInfo.Name);

                foreach (var subDir in dirInfo.EnumerateDirectories())
                {
                    try
                    {
                        // Optional to skip the branches with no files at any level.
                        if (!subDir.EnumerateFiles(searchPattren, 
                            SearchOption.AllDirectories).Any()) continue;

                        var newNode = new TreeNode(subDir.Name);
                        node.Nodes.Add(newNode);
                        CreateTree(subDir, newNode);
                    }
                    catch (Exception ex)
                    {
                        // Skip exceptions like UnauthorizedAccessException
                        // and continue...
                        Console.WriteLine(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        CreateTree(di, result);
        return result;
    });
}

^{Note: You don't need the try..catch blocks if you're under .NET 5+/.NET Core to skip the inaccessible directories and files. Use the EnumerateXXX method overload that takes the EnumerationOptions parameter.}

Now you need async caller like so:

private async void someButton_Click(object sender, EventArgs e)
{        
    // Optional...                
    treeView1.Nodes.Clear();

    var dir = @"...";
    var ext = "txt";
    var node = await CreateTreeAsync(dir, ext);

    if (node.Nodes.Count == 0)
        MessageBox.Show($"No '{ext}' files were found.");
    else
    {
        treeView1.Nodes.Add(node);
        node.Expand();
    }
}

Answer 2

You could convert the DirectoryToTreeNode method to an asynchronous method, and offload any blocking I/O operation to the ThreadPool, by using the Task.Run method:

private async Task<TreeNode> DirectoryToTreeNodeAsync(string path,
    TreeNode parentNode = null)
{
    var node = new TreeNode(parentNode == null ? path : Path.GetFileName(path));
    string[] subdirectories = await Task.Run(() => Directory.GetDirectories(path));
    foreach (string dirPath in subdirectories)
    {
        TreeNode childNode = await DirectoryToTreeNodeAsync(dirPath, node);
        node.Nodes.Add(childNode);
    }
    string[] files = await Task.Run(() => Directory.GetFiles(path));
    foreach (string filePath in files)
    {
        node.Nodes.Add(Path.GetFileName(filePath));
    }
    return node;
}

Notice that no UI control is touched while running on the ThreadPool (inside the Task.Run delegate). All UI controls should be manipulated exclusively by the UI thread.

Usage example:

private async void Button1_Click(object sender, EventArgs e)
{
    Button1.Enabled = false;
    Cursor = Cursors.WaitCursor;
    try
    {
        TreeView1.Nodes.Clear();
        TreeView1.Nodes.Add(
            await DirectoryToTreeNodeAsync(@"C:\Users\Tomer\Desktop\a"));
    }
    finally
    {
        Cursor = Cursors.Default;
        Button1.Enabled = true;
    }
}