Checking for the presence of a file/folder

1. Introduction

Why is it important to check for a file or folder?

Imagine you're keeping a diary, and your app appends entries to the end of a file. Everything works fine while the file exists. But if the file gets deleted by accident, the program will throw an error, and all your brilliant thoughts about the meaning of life or, at worst, about the weather, will disappear without a trace. Similarly, if you want to create a new file to avoid losing anything, it's worth making sure that such a file doesn't already exist.

In real apps — especially in corporate and industrial development — pre-checks for files and folders help avoid not only user-induced errors and critical failures, but also save the team a lot of time, effort and, importantly, spare everyone extra headaches.

Working with the file system in .NET

On the .NET platform, the following main classes are useful for working with files and folders (they live in the System.IO namespace):

• File — static methods for working with files: checks, copy, delete, etc.
• Directory — static methods for working with folders.

To check existence you only need two methods:

• File.Exists(path) — returns true if the file exists.
• Directory.Exists(path) — returns true if the folder exists.

2. Checking for a file before opening

A real-life example

Say you added a function to display the diary contents:

string diaryPath = "diary.txt";
        
if (File.Exists(diaryPath))
{
    // The file exists, read and output the contents
    using var reader = new StreamReader(diaryPath);
    string content = reader.ReadToEnd();
    Console.WriteLine("Your diary:\n" + content);
}
else
{
    Console.WriteLine("Diary file not found!");
    // You can create a new file right away if needed
    File.WriteAllText(diaryPath, "This is the beginning of your diary.\n");
    Console.WriteLine("A new diary file has been created.");
}

In real projects this approach is a must-have: you don't rely on "magic", you control the situation yourself.

3. Checking for a file before writing

Scenario: the app creates reports on a schedule. You need each new report not to overwrite the previous one.

For that it's useful to check: maybe the file already exists? If so — you can, for example, ask the user to enter a different name or create a file with a unique name.

string reportPath = "report.txt";
        
if (File.Exists(reportPath))
{
    Console.WriteLine($"File '{reportPath}' already exists. Rename or delete the old file.");
}
else
{
    using var writer = new StreamWriter(reportPath);
    writer.WriteLine("This is the new report for today!");
    Console.WriteLine("Report file successfully created.");
}

This check will save your users (and yourself!) from unpleasant surprises like overwritten files.

4. Checking for a folder before writing

Files rarely live directly in the project root. They're often placed in special directories: logs/, reports/, data/, etc. Before writing a file it's worth making sure the target folder exists.

string logsDir = "logs";
string logPath = Path.Combine(logsDir, "log.txt"); // Path.Combine helps safely join parts of a path
        
if (!Directory.Exists(logsDir))
{
    Console.WriteLine("Folder 'logs' not found. Creating it...");
    Directory.CreateDirectory(logsDir);
}

using var writer = new StreamWriter(logPath, append: true);
writer.WriteLine($"[{DateTime.Now}] Application started.");
Console.WriteLine("Log file write completed successfully.");

By the way, Directory.CreateDirectory won't throw an error if the folder already exists — it just ignores that, so you can skip the check if you prefer that style.

5. Important nuances

Details: relative and absolute paths

A common newbie mistake: confusing relative and absolute paths. For example, if you write File.Exists("data.txt"), the program looks for the file in the current working folder. Where is that? It depends on where the app was started from.

For reliability use absolute paths or build the path via Path.Combine:

string myDocs = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string filePath = Path.Combine(myDocs, "myapp", "settings.txt");

The path is always explicit, and you won't lose sight of the file.

Important checking details

• Sometimes a check is done, but immediately after it there are further actions with the same file/folder object. Between File.Exists and the subsequent create/delete, time may pass and another process can change the state. In critical scenarios add error handling with try-catch.
• Check not only existence but also access rights. Sometimes the file exists but the user doesn't have permissions for it.
• For directories use Directory.Exists, not File.Exists — otherwise you'll always get false.
• If the path consists of several nested directories, e.g. "data/2024/04", then Directory.CreateDirectory("data/2024/04") will create the whole chain — that's convenient and saves extra checks.

What happens if you don't check?

If you try to open a non-existent file for reading — you'll get FileNotFoundException. If you try to create a file in a non-existent folder — DirectoryNotFoundException. If the program runs under a user's control, they'll see an error and be upset. In production — you lose data/money/time. So "existence checks" aren't pedantry, they're caring for the user (and your own peace of mind).