C# DirectoryInfo Class

The DirectoryInfo class in C# is part of the System.IO namespace and provides functionality for working with directories (folders) in the file system. It allows you to perform various operations on directories, such as creating, deleting, enumerating, and retrieving information about directories.

To use the DirectoryInfo class, you need to include the following using directive at the top of your C# file:

using System.IO;

Here are some common tasks you can perform using the DirectoryInfo class:

Creating a Directory:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.Create();

2. Deleting a Directory:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.Delete();

You can also specify if you want to delete the directory recursively using the Delete method overload:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.Delete(true);

3. Enumerating Files in a Directory:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
FileInfo[] files = directory.GetFiles();

foreach (FileInfo file in files)
{
    Console.WriteLine(file.Name);
}

4. Enumerating Directories in a Directory:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
DirectoryInfo[] subDirectories = directory.GetDirectories();

foreach (DirectoryInfo subDirectory in subDirectories)
{
    Console.WriteLine(subDirectory.Name);
}

5. Checking if a Directory Exists:

string path = "path/to/directory";
if (Directory.Exists(path))
{
    Console.WriteLine("Directory exists.");
}

The DirectoryInfo class provides many more methods and properties for working with directories. You can refer to the official Microsoft documentation for more detailed information and examples: DirectoryInfo Class

C# DirectoryInfo Constructors:

The DirectoryInfo class in C# provides different constructors that allow you to create instances of the class and work with directories. Here are the available constructors:

DirectoryInfo(string path)
- Initializes a new instance of the DirectoryInfo class, representing the specified path.
- Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");

2. DirectoryInfo(string path, string searchPattern)

Initializes a new instance of the DirectoryInfo class, representing the specified path and search pattern.
The search pattern can be used to filter the files and directories within the specified path.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory", "*.txt");

3.DirectoryInfo(string path, string searchPattern, SearchOption searchOption)

Initializes a new instance of the DirectoryInfo class, representing the specified path, search pattern, and search option.
The search option specifies whether to search only the current directory or all subdirectories as well.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory", "*.txt", SearchOption.AllDirectories);

Note: In all the constructors, the path parameter represents the path to the directory.

These constructors allow you to create instances of the DirectoryInfo class, which can be used to perform various operations on directories, such as creating, deleting, enumerating, and retrieving information about directories.

C# DirectoryInfo Properties:

The DirectoryInfo class in C# provides several properties that allow you to retrieve information about a directory. Here are some commonly used properties of the DirectoryInfo class:

FullName:
- Gets the full path of the directory.
- Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
string fullPath = directory.FullName;

2. Name:

Gets the name of the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
string directoryName = directory.Name;

3. Parent:

Gets the parent directory of the current directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
DirectoryInfo parentDirectory = directory.Parent;

4. Exists:

Gets a value indicating whether the directory exists.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
bool directoryExists = directory.Exists;

5. CreationTime:

Gets or sets the creation time of the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
DateTime creationTime = directory.CreationTime;

6. LastWriteTime:

Gets or sets the time when the directory was last written to.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
DateTime lastWriteTime = directory.LastWriteTime;

7. Attributes:

Gets or sets the attributes of the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
FileAttributes attributes = directory.Attributes;

These are just a few examples of the properties provided by the DirectoryInfo class. You can refer to the official Microsoft documentation for more detailed information about all the available properties: DirectoryInfo Class

C# DirectoryInfo Methods:

The DirectoryInfo class in C# provides various methods that allow you to perform operations on directories. Here are some commonly used methods of the DirectoryInfo class:

Create():
- Creates a new directory.
- Example:

DirectoryInfo directory = new DirectoryInfo("path/to/new/directory");
directory.Create();

2. Delete():

Deletes the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.Delete();

You can also specify if you want to delete the directory recursively using the Delete method overload:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.Delete(true);

3. GetFiles():

Retrieves an array of FileInfo objects that represent the files in the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
FileInfo[] files = directory.GetFiles();

4. GetDirectories():

Retrieves an array of DirectoryInfo objects that represent the subdirectories in the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
DirectoryInfo[] subDirectories = directory.GetDirectories();

5. GetFileSystemInfos():

Retrieves an array of FileSystemInfo objects that represent the files and subdirectories in the directory.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
FileSystemInfo[] fileSystemInfos = directory.GetFileSystemInfos();

6. MoveTo(string destDirName):

Moves the directory to a new location.
Example:

DirectoryInfo directory = new DirectoryInfo("path/to/directory");
directory.MoveTo("path/to/new/location");

These are just a few examples of the methods provided by the DirectoryInfo class. You can refer to the official Microsoft documentation for more detailed information about all the available methods: DirectoryInfo Class

C# DirectoryInfo Example:

Certainly! Here’s an example that demonstrates some common operations using the DirectoryInfo class in C#:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string directoryPath = "path/to/directory";

        // Creating a new directory
        DirectoryInfo directory = new DirectoryInfo(directoryPath);
        directory.Create();
        Console.WriteLine("Directory created: " + directory.FullName);

        // Checking if the directory exists
        if (directory.Exists)
        {
            Console.WriteLine("Directory exists.");
        }

        // Getting the files in the directory
        FileInfo[] files = directory.GetFiles();
        Console.WriteLine("Files in the directory:");
        foreach (FileInfo file in files)
        {
            Console.WriteLine(file.Name);
        }

        // Getting the subdirectories in the directory
        DirectoryInfo[] subDirectories = directory.GetDirectories();
        Console.WriteLine("Subdirectories in the directory:");
        foreach (DirectoryInfo subDirectory in subDirectories)
        {
            Console.WriteLine(subDirectory.Name);
        }

        // Moving the directory to a new location
        string newLocation = "path/to/new/location";
        directory.MoveTo(newLocation);
        Console.WriteLine("Directory moved to: " + directory.FullName);

        // Deleting the directory
        directory.Delete();
        Console.WriteLine("Directory deleted.");

        // Checking if the directory exists after deletion
        if (!directory.Exists)
        {
            Console.WriteLine("Directory does not exist.");
        }
    }
}

In this example, we create a new directory, check its existence, retrieve files and subdirectories within it, move the directory to a new location, delete the directory, and verify its existence after deletion.

Remember to replace "path/to/directory" and "path/to/new/location" with the actual paths you want to use in your application.

This example demonstrates some common operations, but you can explore more methods and properties of the DirectoryInfo class based on your specific requirements.

C# DirectoryInfo Example: Deleting Directory

Certainly! Here’s an example that demonstrates how to delete a directory using the DirectoryInfo class in C#:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string directoryPath = "path/to/directory";

        // Checking if the directory exists
        if (Directory.Exists(directoryPath))
        {
            // Deleting the directory
            DirectoryInfo directory = new DirectoryInfo(directoryPath);
            directory.Delete(true);
            Console.WriteLine("Directory deleted: " + directory.FullName);
        }
        else
        {
            Console.WriteLine("Directory does not exist.");
        }
    }
}

In this example, we first check if the directory exists using the Directory.Exists method. If the directory exists, we create a DirectoryInfo instance representing the directory and call the Delete method to delete it. The boolean parameter true in the Delete method is used to delete the directory recursively, including all its files and subdirectories.

If the directory doesn’t exist, we display a message indicating that the directory does not exist.

Remember to replace "path/to/directory" with the actual path of the directory you want to delete in your application.

This example demonstrates how to delete a directory using the DirectoryInfo class. Make sure to handle any exceptions that may occur during the deletion process, such as IOException or UnauthorizedAccessException, which can be thrown if the directory or any of its files are in use or if the user doesn’t have sufficient permissions to delete the directory.