Introduction

Checking whether a directory is empty sounds trivial, but the fastest approach depends on how much of the directory you force the runtime to inspect. In .NET, the main difference is whether you enumerate lazily or allocate a full array of names before making the decision.

Prefer Lazy Enumeration

If you only need a yes-or-no answer, use Directory.EnumerateFileSystemEntries and stop as soon as the first item appears. That avoids building an in-memory array of every file and subdirectory.

1using System;
2using System.IO;
3using System.Linq;
4
5class Program
6{
7    static bool IsDirectoryEmpty(string path)
8    {
9        return !Directory.EnumerateFileSystemEntries(path).Any();
10    }
11
12    static void Main()
13    {
14        string path = @"C:\Temp\TestFolder";
15
16        if (IsDirectoryEmpty(path))
17        {
18            Console.WriteLine("Directory is empty.");
19        }
20        else
21        {
22            Console.WriteLine("Directory contains at least one entry.");
23        }
24    }
25}

This is usually the best default because Any() short-circuits. Once the first item is found, enumeration stops. On a directory with many entries, that is much cheaper than calling GetFiles or GetFileSystemEntries, which create arrays first.

Files Only vs Any Entry

Be clear about what "empty" means in your application. Some code treats a folder as empty only when there are no files. Other code considers child directories as content too.

If you want to check for files only, use EnumerateFiles:

1using System;
2using System.IO;
3using System.Linq;
4
5class Program
6{
7    static bool HasNoFiles(string path)
8    {
9        return !Directory.EnumerateFiles(path).Any();
10    }
11
12    static void Main()
13    {
14        Console.WriteLine(HasNoFiles(@"C:\Logs"));
15    }
16}

If you want a directory with subfolders to count as non-empty, stay with EnumerateFileSystemEntries. That covers both files and directories.

Using DirectoryInfo

DirectoryInfo is useful when you already work with object-oriented file system APIs. The performance story is similar as long as you keep lazy enumeration.

1using System;
2using System.IO;
3using System.Linq;
4
5class Program
6{
7    static bool IsEmpty(DirectoryInfo directory)
8    {
9        return !directory.EnumerateFileSystemInfos().Any();
10    }
11
12    static void Main()
13    {
14        var directory = new DirectoryInfo(@"C:\Archive");
15        Console.WriteLine(IsEmpty(directory));
16    }
17}

This reads cleanly if you already have a DirectoryInfo instance from other code. Otherwise, the static Directory methods are simpler.

Why GetFiles Can Be Wasteful

You will often see code like this:

bool isEmpty = Directory.GetFiles(path).Length == 0 &&
               Directory.GetDirectories(path).Length == 0;

It works, but it does more work than necessary:

• It allocates arrays.
• It may traverse more of the directory than needed.
• It makes two calls instead of one.

For small folders the difference may not matter. For large folders, network shares, or repeated checks inside a service, lazy enumeration is the better design.

Handling Missing or Inaccessible Directories

Production code should not assume the path exists or that the process can read it. Wrap the check so the caller gets a predictable result.

1using System;
2using System.IO;
3using System.Linq;
4
5class Program
6{
7    static bool TryIsDirectoryEmpty(string path, out bool isEmpty)
8    {
9        isEmpty = false;
10
11        try
12        {
13            if (!Directory.Exists(path))
14            {
15                return false;
16            }
17
18            isEmpty = !Directory.EnumerateFileSystemEntries(path).Any();
19            return true;
20        }
21        catch (UnauthorizedAccessException)
22        {
23            return false;
24        }
25        catch (IOException)
26        {
27            return false;
28        }
29    }
30
31    static void Main()
32    {
33        if (TryIsDirectoryEmpty(@"C:\Restricted", out bool isEmpty))
34        {
35            Console.WriteLine($"Empty: {isEmpty}");
36        }
37        else
38        {
39            Console.WriteLine("Could not inspect the directory.");
40        }
41    }
42}

This pattern is useful when folder access is optional and failure should not crash the process.

Common Pitfalls

• Using GetFiles and GetDirectories for a simple emptiness check. It works, but it allocates more memory and does extra work.
• Forgetting that subdirectories count as content for many use cases. If you only check files, you might mistakenly delete a directory that still contains child folders.
• Assuming Directory.Exists is enough. A directory can exist and still throw UnauthorizedAccessException during enumeration.
• Treating hidden and system entries as invisible. The file system still considers them entries unless you explicitly filter them out.

Summary

• Use Directory.EnumerateFileSystemEntries(path).Any() for the fastest general emptiness check.
• Use EnumerateFiles only if your business rule ignores subdirectories.
• Prefer lazy enumeration over GetFiles or GetDirectories when you only need a boolean result.
• Handle missing paths and permission failures in production code.
• Define "empty" carefully before you choose the API.