Path Exists and Directory Class - C#

Problem

Ensure your specific path exists on the disk. Your program requires a certain directory, such as one that stores XML files, text files, or images, to be present. In the Open File dialog, we assume this folder is there, and we require it at startup.

Solution: C#

Unfortunately, you can almost never be sure that a directory is present between runs of your application. The user may delete it, or it might be lost due to some other interaction on the system (such as a cleanup utility). Your installation or upgrade process might have mistakenly removed it.

How can we ensure the path exists?

The Paint.NET code I am showing requires that there be a palettes directory. (There are color files stored in this directory apparently.) To ensure that the directory exists, the code includes a method called EnsurePalettesPathExists, which is called in several places. Let's look at the implementation.

namespace PaintDotNet
{
    internal sealed class PaletteCollection
    {
        public static void EnsurePalettesPathExists()
        {
            // Set to folder path we must ensure exists.
            string palettesPath = PalettesPath;
            try
            {
                // If the directory doesn't exist, create it.
                if (!Directory.Exists(palettesPath))
                {
                    Directory.CreateDirectory(palettesPath);
                }
            }
            catch (Exception)
            {
                // Fail silently
            }
        }
    }
}

• Logic deals with directory
  This method simply checks to see if the path exists, and if it doesn't, it tries to create it. Basically, it tries to ensure the location exists if it is at all possible to ensure that.
  (This could still fail due to strange permissions or locked file problems.)
• Fails silently
  The code catches it own exceptions when it cannot do its job. Remember, you should use exceptions when code cannot do what it needs to do.
• System.IO.Directory
  Directory here is a static class in the IO namespace. You can call Exists and CreateDirectory on it directly, which is what the above code does.

How does this help?

This code allows us to isolate some of the mundane file system problems from the other code. This method could still fail, but in most cases, it will accomplish its goal and ensure the path exists. Next I show how it is used in Paint.NET's Save File method. It is called at the start of the method, and it helps simplify the Save method.

public void Save()
{
    EnsurePalettesPathExists();

    string palettesPath = PalettesPath;
    foreach (string paletteName in this.palettes.Keys)
    {
        // Code here...
    }
}

And the next caller I want to show in Paint.NET's source is an event handler that is called when the user opens a palette folder. (Obviously, if the user opens a folder, it must be there! This situation might be caused if the user deleted the folder in the meantime. Coding defensively is the finest skill of a programmer.)

namespace PaintDotNet
{
    internal class ColorsForm : FloatingToolForm
    {
        private void OnOpenPalettesFolderClickedHandler(object sender, EventArgs e)
        {
            PaletteCollection.EnsurePalettesPathExists();
            try
            {
                // Code...
            }
            catch (Exception)
            {
                // More error handling.
            }
        }
    }
}

Does it work?

This is a professional and tested way of ensuring that fewer IO problems arise. It is a safeguard and these sorts of checks are critical for user-centric programs. This program is a world-class drawing program that I run every day, and it never crashes.

Conclusion

Here we can follow the example of Paint.NET and ensure paths exist. It shows some examples of exception handling, and the Directory class in System.IO. Reduce code duplication with elegant methods that ensure certain conditions. In doing so, your program will be more resilient to user mistakes.