Some applications must read the folder structure beneath an existing folder or for an entire disk or attached device. The standard method in the Directory class can cause problems when used in this way. An alternative is to recursively read the folders.

Reading Folders

It is common to wish to read the entire folder structure of a disk when you are creating software that works with the file system. For example, you may wish to populate a TreeView control with the complete list of directories, or you might read the folders in order to compare them with another directory or with a backup copy.

The Directory class, which is a standard type within the .NET framework, includes a method, named GetDirectories, that allows you to read the folders within a given path, returning their names in a string array. You can use further methods of the Directory and File classes to work with the folders and their contents. An example of the GetDirectories method is shown below. This returns a list of folder names that can be found in the root of the C: drive.

NB: To run this code you need to reference the System.IO namespace so add the directive, "using System.IO;" to your code.

string[] folders = Directory.GetDirectories(@"c:\");

To instruct the method to work recursively, reading the folders, their subfolders and directories beneath these until the folder structure is exhausted, you can add the AllDirectoriessearch option, as shown below:

string[] folders = Directory.GetDirectories(@"c:\", "*", SearchOption.AllDirectories);

Unfortunately, this has problems. Key amongst these is that some of the folders that you attempt to read could be configured so that the current user may not access them. Rather than ignoring folders to which you have restricted access, the method throws anUnauthorizedAccessException. However, we can circumvent this problem by creating our own recursive folder search code.

Folder Recursion

Let's start with some simple folder recursion code that recreates the flawed functionality of the GetDirectories method. We'll create it within a console application and show its activity by outputting folder name as they are examined. In a real application you could build and return a list or array, or use an iterator to return the values as they are required, thus avoiding the delay caused by reading large folder structures ahead of the time they are needed.

The code below shows the basic recursive method. The Main method callsShowAllFoldersUnder, passing in the starting path. In this case we are going to display all folders starting from the root of the C: drive.

ShowAllFoldersUnder does the real work. When this method is called it uses the basic version of GetDirectories to obtain the folder list for directories immediately within the provided path. It then loops through these folders, first displaying the name, then calling itself, passing the folder name, to look one level deeper. This recursive nature causes all folders to be examined, unless an exception is thrown.

static void Main(string[] args)
{
    Console.WriteLine(@"c:\");
    ShowAllFoldersUnder(@"c:\", 0);
}

private static void ShowAllFoldersUnder(string path, int indent)
{
    foreach (string folder in Directory.GetDirectories(path))
    {
        Console.WriteLine("{0}{1}", new string(' ', indent), Path.GetFileName(folder));
        ShowAllFoldersUnder(folder, indent + 2);
    }
}

To avoid UnauthorizedAccessExceptions stopping the execution, we need to add a try / catch block around the foreach loop. We can use this to catch only that type of exception and ignore it. This means that the folders to which the user does not have access will not be displayed. The updated ShowAllFolders code is as follows.

private static void ShowAllFoldersUnder(string path, int indent)
{
    try
    {
        foreach (string folder in Directory.GetDirectories(path))
        {
            Console.WriteLine("{0}{1}", new string(' ', indent), Path.GetFileName(folder));
            ShowAllFoldersUnder(folder, indent + 2);
        }
    }
    catch (UnauthorizedAccessException) { }
}

Reparse Points

Something else that we must deal with is reparse points, or junction points. Most disks used by Windows operating systems are formatted using the New Technology File System, or NTFS. This allows disks to be mounted in interesting ways. In addition to the usual assignment of drive letters, such as C:, disks can be mounted within folders. This means that when you use Windows Explorer to browse to the C:\OtherDisk folder, you may be seeing the contents of another disk or partition altogether.

Junction points generate a problem when recursively scanning folders; drives can be mounted in such a way as to create infinite directory structures. For example, the disk containing your C: drive could be mounted within a folder named, "C:\Infinite". If you looked inside this folder you would find everything that is in the root of C:, including the "Infinite" folder. You could continue to drill down into that folder, each time seeing the same subfolders and files.

To avoid infinite loops, we need to check that a folder is not a junction point. We can do this by reading each folder's attributes and checking if it is a reparse point. To get the attributes we use the File.GetAttributes method, which returns an enumeration that represents a bit field. We can then use the bitwise AND operator to check for the existence of the ReparsePointflag.

Using this information we can create the final version of ShowAllFoldersUnder, as follows:

private static void ShowAllFoldersUnder(string path, int indent)
{
    try
    {
        if ((File.GetAttributes(path) & FileAttributes.ReparsePoint)
            != FileAttributes.ReparsePoint)
        {
            foreach (string folder in Directory.GetDirectories(path))
            {
                Console.WriteLine(
                    "{0}{1}", new string(' ', indent), Path.GetFileName(folder));
                ShowAllFoldersUnder(folder, indent + 2);
            }
        }
    }
    catch (UnauthorizedAccessException) { }
}