Export (0) Print
Expand All
6 out of 431 rated this helpful - Rate this topic

Directory Class

Exposes static methods for creating, moving, and enumerating through directories and subdirectories.

For a list of all members of this type, see Directory Members.

System.Object
   System.IO.Directory

[Visual Basic]
NotInheritable Public Class Directory
[C#]
public sealed class Directory
[C++]
public __gc __sealed class Directory
[JScript]
public class Directory

Thread Safety

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

Remarks

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 File 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.

Note   In members that accept a path as an input string, that path must be well-formed or an exception is raised. For example, if a path is fully qualified but begins with a space, the path is not trimmed in methods of the class. Therefore, the path is malformed and an 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.

For an example of using this class, see the Example section below. The following table lists examples of other typical or related I/O tasks.

To do this... See the example in this topic...
Create a text file. Writing Text to a File
Write to a text file. Writing Text to a File
Read from a text file. Reading Text from a File
Copy a directory. Directory
Rename or move a directory. Directory.Move

DirectoryInfo.MoveTo

Delete a directory. Directory.Delete

DirectoryInfo.Delete

Create a directory. CreateDirectory

Directory

Create a subdirectory. CreateSubdirectory
See the files in a directory. Name
See the subdirectories of a directory. GetDirectories

GetDirectories

See all the files in all subdirectories of a directory. GetFileSystemInfos
Find the size of a directory. Directory
Determine if a file exists. Exists
Sort files in a directory by size. GetFileSystemInfos
Determine if a directory exists. Exists

Example

[Visual Basic, C#, C++] The following example determines whether a specified directory exists, deletes it if it does, and creates it if it does not. This example then moves the directory, creates a file in the directory, and counts the files in the directory.

[Visual Basic] 
Imports System
Imports System.IO

Public Class Test

    Public Shared Sub Main()
        'Specify the directories you want to manipulate.
        Dim path As String = "c:\MyDir"
        Dim target As String = "c:\TestDir"

        Try
            ' Determine whethers the directory exists.
            If Directory.Exists(path) = False Then
                ' Create the directory.
                Directory.CreateDirectory(path)
            End If

            If Directory.Exists(target) Then
                ' Delete the target to ensure it is not there.
                Directory.Delete(target, True)
            End If

            ' Move the directory.
            Directory.Move(path, target)

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

            'Count the files in the target.
            Console.WriteLine("The number of files in {0} is {1}", _
              target, Directory.GetFiles(target).Length)

        Catch e As Exception
            Console.WriteLine("The process failed: {0}", e.ToString())
        End Try
    End Sub
End Class

[C#] 
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";

        try 
        {
            // Determine whether the directory exists.
            if (!Directory.Exists(path)) 
            {
                // Create the directory it does not exist.
                Directory.CreateDirectory(path);
            }

            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 {}
    }
}

[C++] 
#using <mscorlib.dll>

using namespace System;
using namespace System::IO;

void main() {
    // Specify the directories you want to manipulate.
    String* path = S"c:\\MyDir";
    String* target = S"c:\\TestDir";

    try {
        // Determine whether the directory exists.
        if (!Directory::Exists(path)) {
            // Create the directory it does not exist.
            Directory::CreateDirectory(path);
        }

        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(String::Concat(target, S"\\myfile.txt"));

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

[Visual Basic] 
' The following example calculates the size of a directory
' and its subdirectories, if any, and displays the total size
' in bytes.
Imports System
Imports System.IO
Imports Microsoft.VisualBasic



Public Class ShowDirSize

    Public Shared Function DirSize(ByVal d As DirectoryInfo) As Long
        Dim Size As Long = 0
        ' Add file sizes.
        Dim fis As FileInfo() = d.GetFiles()
        Dim fi As FileInfo
        For Each fi In fis
            Size += fi.Length
        Next fi
        ' Add subdirectory sizes.
        Dim dis As DirectoryInfo() = d.GetDirectories()
        Dim di As DirectoryInfo
        For Each di In dis
            Size += DirSize(di)
        Next di
        Return Size
    End Function 'DirSize

    Public Overloads Shared Sub Main(ByVal args() As String)
        If args.Length <> 1 Then
            Console.WriteLine("You must provide a directory argument at the command line.")
        Else
            Dim d As New DirectoryInfo(args(0))
            Console.WriteLine("The size of {0} and its subdirectories is {1} bytes.", d, DirSize(d))
        End If
    End Sub 'Main
End Class 'ShowDirSize

[C#] 
// 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);   
        }
        return(Size);  
    }
    public static void Main(string[] args) 
    {
        if (args.Length != 1) 
        {
            Console.WriteLine("You must provide a directory argument at the command line.");    
        } 
        else 
        {  
            DirectoryInfo d = new DirectoryInfo(args[0]);
            Console.WriteLine("The size of {0} and its subdirectories is {1} bytes.", d, DirSize(d));
        }
    }
}

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

#using <mscorlib.dll>

using namespace System;
using namespace System::IO;

long DirSize(DirectoryInfo* d) {
   long Size = 0;
   // Add file sizes.
   FileInfo*  fis[] = d->GetFiles();
   System::Collections::IEnumerator* myEnum = fis->GetEnumerator();
   while (myEnum->MoveNext()) {
      FileInfo* fi = __try_cast<FileInfo*>(myEnum->Current);
      Size += (long)fi->Length;
   }
   // Add subdirectory sizes.
   DirectoryInfo*  dis[] = d->GetDirectories();
   while (myEnum->MoveNext()) {
      DirectoryInfo* di = __try_cast<DirectoryInfo*>(myEnum->Current);
      Size += DirSize(di);
   }
   return Size;
}

int main() {
   String* args[] = Environment::GetCommandLineArgs();
   if (args->Length != 2) {
      Console::WriteLine(S"You must provide a directory argument at the command line.");
   } else {
      DirectoryInfo* d = new DirectoryInfo(args[1]);
      Console::WriteLine(S"The size of {0} and its subdirectories is {1} bytes.", 
         d, __box(DirSize(d)));
   }
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.IO

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework

Assembly: Mscorlib (in Mscorlib.dll)

See Also

Directory Members | System.IO Namespace | File | DirectoryInfo | FileInfo | Working with I/O | Reading Text from a File | Writing Text to a File | Basic File I/O | Reading and Writing to a Newly Created Data File

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.