This simple function works well and meets the questions requirements.

private List<string> GetFiles(string path, string pattern)

{

    var files = new List<string>();



    try 

    { 

        files.AddRange(Directory.GetFiles(path, pattern, SearchOption.TopDirectoryOnly));

        foreach (var directory in Directory.GetDirectories(path))

            files.AddRange(GetFiles(directory, pattern));

    } 

    catch (UnauthorizedAccessException) { }



    return files;

}

Also check, How to: Iterate Through a Directory Tree.

A simple way to do this is by using a List for files and a Queue for directories.
It conserves memory.
If you use a recursive program to do the same task, that could throw OutOfMemory exception.
The output: files added in the List, are organised according to the top to bottom (breadth first) directory tree.

public static List<string> GetAllFilesFromFolder(string root, bool searchSubfolders) {

    Queue<string> folders = new Queue<string>();

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

    folders.Enqueue(root);

    while (folders.Count != 0) {

        string currentFolder = folders.Dequeue();

        try {

            string filesInCurrent = System.IO.Directory.GetFiles(currentFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);

            files.AddRange(filesInCurrent);

        }

        catch {

            // Do Nothing

        }

        try {

            if (searchSubfolders) {

                string foldersInCurrent = System.IO.Directory.GetDirectories(currentFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);

                foreach (string _current in foldersInCurrent) {

                    folders.Enqueue(_current);

                }

            }

        }

        catch {

            // Do Nothing

        }

    }

    return files;

}

Steps:

1. Enqueue the root in the queue


2. In a loop, Dequeue it, Add the files in that directory to the list, and Add the subfolders to the queue.


3. Repeat untill the queue is empty.

I know this question is somewhat old, but I had this same problem today and I found the following article that explains a 'folder recursion' solution in detail.

The article acknowledges the flaws of the GetDirectories() method... :

Unfortunately, this [using the GetDirectories() method] 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 an
UnauthorizedAccessException. However, we can circumvent this problem
by creating our own recursive folder search code.

... and then introduces the solution in detail:

http://www.blackwasp.co.uk/FolderRecursion.aspx

This should answer the question. I've ignored the issue of going through subdirectories, I'm assuming you have that figured out.

Of course, you don't need to have a seperate method for this, but you might find it a useful place to also verify the path is valid, and deal with the other exceptions that you could encounter when calling GetFiles().

Hope this helps.

private string GetFiles(string path)

{

    string files = null;

    try

    {

       files = Directory.GetFiles(path);

    }

    catch (UnauthorizedAccessException)

    {

       // might be nice to log this, or something ...

    }



    return files;

}



private void Processor(string path, bool recursive)

{

    // leaving the recursive directory navigation out.

    string files = this.GetFiles(path);

    if (null != files)

    {

        foreach (string file in files)

        {

           this.Process(file);

        }

    }

    else

    {

       // again, might want to do something when you can't access the path?

    }

}

see https://stackoverflow.com/a/10728792/89584 for a solution that handles the UnauthorisedAccessException problem.

All the solutions above will miss files and/or directories if any calls to GetFiles() or GetDirectories() are on folders with a mix of permissions.

Here's a full-featured, .NET 2.0-compatible implementation.

You can even alter the yielded List of files to skip over directories in the FileSystemInfo version!

(Beware null values!)

public static IEnumerable<KeyValuePair<string, string>> GetFileSystemInfosRecursive(string dir, bool depth_first)

{

    foreach (var item in GetFileSystemObjectsRecursive(new DirectoryInfo(dir), depth_first))

    {

        string result;

        var children = item.Value;

        if (children != null)

        {

            result = new string[children.Count];

            for (int i = 0; i < result.Length; i++)

            { result[i] = children[i].Name; }

        }

        else { result = null; }

        string fullname;

        try { fullname = item.Key.FullName; }

        catch (IOException) { fullname = null; }

        catch (UnauthorizedAccessException) { fullname = null; }

        yield return new KeyValuePair<string, string>(fullname, result);

    }

}



public static IEnumerable<KeyValuePair<DirectoryInfo, List<FileSystemInfo>>> GetFileSystemInfosRecursive(DirectoryInfo dir, bool depth_first)

{

    var stack = depth_first ? new Stack<DirectoryInfo>() : null;

    var queue = depth_first ? null : new Queue<DirectoryInfo>();

    if (depth_first) { stack.Push(dir); }

    else { queue.Enqueue(dir); }

    for (var list = new List<FileSystemInfo>(); (depth_first ? stack.Count : queue.Count) > 0; list.Clear())

    {

        dir = depth_first ? stack.Pop() : queue.Dequeue();

        FileSystemInfo children;

        try { children = dir.GetFileSystemInfos(); }

        catch (UnauthorizedAccessException) { children = null; }

        catch (IOException) { children = null; }

        if (children != null) { list.AddRange(children); }

        yield return new KeyValuePair<DirectoryInfo, List<FileSystemInfo>>(dir, children != null ? list : null);

        if (depth_first) { list.Reverse(); }

        foreach (var child in list)

        {

            var asdir = child as DirectoryInfo;

            if (asdir != null)

            {

                if (depth_first) { stack.Push(asdir); }

                else { queue.Enqueue(asdir); }

            }

        }

    }

}