How to check if a recursive method has ended?

I've just finished making this recursive method:

/// <summary>
/// Recursively process a given directory and add its file to Library.xml
/// </summary>
/// <param name="sourceDir">Source directory</param>
public void ProcessDir(string sourceDir)
{
    string[] fileEntries = Directory.GetFiles(sourceDir, "*.mp3");
    foreach (string fileName in fileEntries)
    {
        Song newSong = new Song();
        newSong.ArtistName = "test artist";
        newSong.AlbumName = "test album";
        newSong.Name = "test song title";
        newSong.Length = 1234;
        newSong.FileName = fileName;

        songsCollection.S开发者_开发问答ongs.Add(newSong);
    }

    string[] subdirEntries = Directory.GetDirectories(sourceDir);
    foreach (string subdir in subdirEntries)
    {
        if ((File.GetAttributes(subdir) & FileAttributes.ReparsePoint) != FileAttributes.ReparsePoint)
        {
            ProcessDir(subdir);
        }
    }
}

Everything is working as expected, the only problem I'm having is: How do I know when this method finishes execution? Is there something made for that very purpose in .NET?

There's nothing special in .NET that tells you this... Basically, the first call to ProcessDir will return after the recursion has ended.

Well, you could always put a line of code indicating the end of execution after your initial ProcessDir call:

ProcessDir("MyDir");
Console.WriteLine("Done!");

You could try using a global variable to keep track of it.

private int _processDirTrack = 0;

public void ProcessDir(string sourceDir)
{
    _processDirTrack++;  // Increment at the start of each

    string[] fileEntries = Directory.GetFiles(sourceDir, "*.mp3");
    foreach (string fileName in fileEntries)
    {
        Song newSong = new Song();
        newSong.ArtistName = "test artist";
        newSong.AlbumName = "test album";
        newSong.Name = "test song title";
        newSong.Length = 1234;
        newSong.FileName = fileName;

        songsCollection.Songs.Add(newSong);
    }

    string[] subdirEntries = Directory.GetDirectories(sourceDir);
    foreach (string subdir in subdirEntries)
    {
        if ((File.GetAttributes(subdir) & FileAttributes.ReparsePoint) != FileAttributes.ReparsePoint)
        {
            ProcessDir(subdir);
        }
    }

    _processDirTrack--;  // Decrement after the recursion. Fall through means it got to
                         // the end of a branch

    if(_processDirTrack == 0)
    {
        Console.WriteLine("I've finished with all of them.");
    }
}

I'm assuming the (albeit correct) answer RQDQ provided isn't the one you are looking for?

In case you have a long running task of which you want to check how far it is along you can use a BackgroundWorker.

Ofcourse this background worker doesn't magically know how much more files to process, so you have to call ReportProgress whenever you can give an estimate of how far along you are.

In order to try to estimate how much longer the processing will take, you could try the following:

• Check for total disk space the folder occupies, and keep track of much you already processed.
• Check for amount of files you have to process vs. how much you still have to process.

If you're wanting to know when it ends to signal/start another process in your application, you could raise an event. This may be over kill, but hey, it's another way to look at it if it suits your need. You just need to add an event to the class where ProcessDir() is a member.

private int _processDirTrack = 0;
public event EventHandler DirProcessingCompleted;

At the end of your method you would raise your event like so

DirProcessingCompleted(this, new EventArgs());

You subscribe to these events with an eventhandler somewhere else in your code

myClass.DirProcessingCompleted += new EventHandler(ProcessingComplete_Handler);

Note: you don't have to subscribe to an event in this manner; you could also subscribe with a delegate or lambda expression instead.

To wrap it all up you create your method that is called whenever an event is raised by the object.

private void ProcessingComplete_Handler(object sender, EventArgs e)
{
    // perform other operations here that are desirable when the event is raised ...
}

I'm guessing what you're trying to figure out is how to know that you've reached the deepest level of recursion that is going to occur.

In this case, you'll know that you're in the last recursive call of the function when subdirEntries is empty, since the function will no longer recurse at that point. That's the best you can do, there's no universal answer as to how to know when a function will cease to recurse. It's entirely dependent upon what the conditions to recurse are.

Edit: Wanted to clarify. This will check each time you end a single chain of recursions. Considering your code can recurse multiple times per call, my solution will only signify the end of a single chain of recursions. In the case of recursively navigating a tree, this will occur at every leaf node, not at the deepest level of recursion.