This documentation is archived and is not being maintained.

Directory Class

Exposes static methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited.

Namespace:  System.IO
Assembly:  mscorlib (in mscorlib.dll)

public static class Directory

Use the Directory class for typical operations such as copying, moving, renaming, creating, and deleting directories. You can also use the Directory class to get and set DateTime information related to the creation, access, and writing of a directory.

Because all Directory methods are static, it might be more efficient to use a Directory method rather than a corresponding DirectoryInfo instance method if you want to perform only one action. Most Directory methods require the path to the directory that you are manipulating.

The static methods of the Directory class perform security checks on all methods. If you are going to reuse an object several times, consider using the corresponding instance method of DirectoryInfo instead, because the security check will not always be necessary.


In members that accept a path as an input string, that path must be well-formed or an exception is raised; however, if a path is fully qualified but begins with a space, the space is not omitted but no exception is raised. Similarly, a path or a combination of paths cannot be fully qualified twice. For example, "c:\temp c:\windows" also raises an exception in most cases. Ensure that your paths are well-formed when using methods that accept a path string.

In members that accept a path, the path can refer to a file or just a directory. The specified path can also refer to a relative path or a Universal Naming Convention (UNC) path for a server and share name. For example, all the following are acceptable paths:

  • "c:\\MyDir" in C#, or "c:\MyDir" in Visual Basic.

  • "MyDir\\MySubdir" in C#, or "MyDir\MySubDir" in Visual Basic.

  • "\\\\MyServer\\MyShare" in C#, or "\\MyServer\MyShare" in Visual Basic.

By default, full read/write access to new directories is granted to all users. Demanding permission for a directory where the path string ends with the directory separator character results in demanding permissions for all of the contained subdirectories (for example "C:\Temp\"). If permissions are required only for a specific directory, the string should end with a "." character (for example "C:\Temp\.").

For a list of common I/O tasks, see Common I/O Tasks.

The following code example determines whether a specified directory exists, deletes it if it exists, and creates it if it does not exist. This example then moves the directory, creates a file in the directory, and counts the files in the directory.

using System;
using System.IO;

class Test 
    public static void Main() 
        // Specify the directories you want to manipulate.
        string path = @"c:\MyDir";
        string target = @"c:\TestDir";

            // Determine whether the directory exists. 
            if (!Directory.Exists(path)) 
                // Create the directory it does not exist.

            if (Directory.Exists(target)) 
                // Delete the target to ensure it is not there.
                Directory.Delete(target, true);

            // Move the directory.
            Directory.Move(path, target);

            // Create a file in the directory.
            File.CreateText(target + @"\myfile.txt");

            // Count the files in the target directory.
            Console.WriteLine("The number of files in {0} is {1}",
                target, Directory.GetFiles(target).Length);
        catch (Exception e) 
            Console.WriteLine("The process failed: {0}", e.ToString());
        finally {}

The following code example demonstrates how to calculate the size of a directory.

// The following example calculates the size of a directory 
// and its subdirectories, if any, and displays the total size 
// in bytes. 

using System;
using System.IO;

public class ShowDirSize 
    public static long DirSize(DirectoryInfo d) 
        long Size = 0;    
        // Add file sizes.
        FileInfo[] fis = d.GetFiles();
        foreach (FileInfo fi in fis) 
            Size += fi.Length;    
        // Add subdirectory sizes.
        DirectoryInfo[] dis = d.GetDirectories();
        foreach (DirectoryInfo di in dis) 
            Size += DirSize(di);   
    public static void Main(string[] args) 
        if (args.Length != 1) 
            Console.WriteLine("You must provide a directory argument at the command line.");    
            DirectoryInfo d = new DirectoryInfo(args[0]);
            long dsize = DirSize(d);
            Console.WriteLine("The size of {0} and its subdirectories is {1} bytes.", d, dsize);


Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360, Zune

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0, 1.0

XNA Framework

Supported in: 3.0, 2.0, 1.0