New User Help

Recursion is pretty simple once you you figure it out the first time. :)

The key ingredients of the recursive method is the return value *or* ref(erence) parameters. Probably the easiest example is code that will go through a file directory and all sub-directories and do something with each file it finds, then return the number of text files it found.

Please excuse me if this doesn't compile, I wrote this in this text box, but it should outline how the recursive nature of this method works.

private int myRecursiveDir(DirectoryInfo currentDir)
{
   int fileCount = 0;

   foreach(File currentFile in currentDir.GetFiles("*.txt"))
   {
    // Do Something with the file...
    fileCount++; // We processed a file, increment count.
   }
   foreach(DirectoryInfo subDir in currentDir.GetDirectories())
   {
    // Add the total of our recursive to our current file count...
     fileCount += myRecursiveDir(subDir);// Recursive call.
   }

   return fileCount; // Return the sum of this directory's text file count.

}

Walkthrough: When the method is first called the file count initializes to 0. Each directory it walks through starts with 0 files. We search the current directory for files using a loop and increment this directory's file count. Next we check for sub directories and will call our method recursively for each sub directory. Each sub-directory will start a new count of files, and then check each of its sub-directories. We add the total of each sub-directory to the parent directory's file count until we eventually get back up to our root directory (first dir passed in) which will return the sum of all found text files in all sub-directories.

In simple examples you can use the return value of the method, but in more complex examples where you can use recursion, you might want to pass reference type parameters (i.e. collection classes) or reference variables to use in the method and return the adjusted results back up to the initial calling method.

The biggest strength of recursion is that it is flexible. It doesn't care if it gets called 1-deep or 1000-deep. But this is also its risk. Recursive methods use the stack and memory so if something gets going too deep and allocating chunks of memory you could find it running out of memory or stack.