File And Directory Operations In C# Complete Guide

Last Update:2025-06-23T00:00:00 .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION. 11 mins read Difficulty-Level: beginner

Understanding the Core Concepts of File and Directory Operations in C#

File and Directory Operations in C#

1. Namespaces

System.IO: Contains types that allow reading and writing to files and data streams.
System.IO.File: Provides methods for the creation, copying, deletion, moving, and opening of files.
System.IO.Directory: Provides methods for the creation, copying, deletion, moving, and opening of directories.
System.IO.FileInfo: Represents attributes of a file and provides methods to create, copy, delete, move, and open files.
System.IO.DirectoryInfo: Represents attributes and methods to create, copy, delete, move, and search through directories and subdirectories.

2. Creating Files and Directories

File.Create(): Opens a FileStream on the specified path.

using (FileStream fs = File.Create("example.txt"))
{
    // Use the FileStream
}

Directory.CreateDirectory(): Creates all directories and subdirectories specified in a path.
```
Directory.CreateDirectory(@"C:\MyProject\Documentation");
```

3. Writing to Files

File.WriteAllText(): Writes specified text to a file, creating the file if it does not already exist.
```
File.WriteAllText("example.txt", "Hello, world!");
```

StreamWriter: Provides a stream writer that can write characters to a byte stream in a particular encoding.

using (StreamWriter writer = new StreamWriter("example.txt"))
{
    writer.WriteLine("Hello, world!");
    writer.WriteLine("Welcome to C#!");
}

4. Reading from Files

File.ReadAllText(): Opens a text file, reads all lines of the file, and closes the file.
```
string content = File.ReadAllText("example.txt");
Console.WriteLine(content);
```

StreamReader: Provides a stream reader that can read characters from a byte stream in a specified encoding.

using (StreamReader reader = new StreamReader("example.txt"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

5. Appending Text to Files

File.AppendAllText(): Opens or creates a file, appends the specified string to it, and then closes the file.
```
File.AppendAllText("example.txt", "\nAppending new line.");
```

StreamWriter: Opens an existing file without erasing its content.

using (StreamWriter writer = File.AppendText("example.txt"))
{
    writer.WriteLine("\nAppending new line.");
}

6. Deleting Files and Directories

File.Delete(): Deletes a file specified by its path.
```
File.Delete("example.txt");
```
Directory.Delete(): Deletes the specified directory and, if indicated, any subdirectories and files in the directory.
```
Directory.Delete(@"C:\MyProject\Documentation", true);
```

7. Moving and Renaming Files and Directories

File.Move(): Moves a specified file to a new location, providing the option to specify a new file name.
```
File.Move("example.txt", "new_example.txt");
```
Directory.Move(): Moves a specified directory to a new location.
```
Directory.Move(@"C:\OldFolder", @"C:\NewFolder");
```

8. Checking File and Directory Attributes

File.Exists(): Determines whether the specified file exists.

if (File.Exists("example.txt"))
{
    Console.WriteLine("File exists.");
}

Directory.Exists(): Determines whether the specified directory exists.

if (Directory.Exists(@"C:\MyProject\Documentation"))
{
    Console.WriteLine("Directory exists.");
}

File.GetCreationTime(): Returns the creation date and time of the specified file.

DateTime creationTime = File.GetCreationTime("example.txt");
Console.WriteLine($"Creation Time: {creationTime}");

Directory.GetCreationTime(): Returns the creation date and time of the specified directory.

DateTime creationTime = Directory.GetCreationTime(@"C:\MyProject");
Console.WriteLine($"Creation Time: {creationTime}");

9. Enumerating Files and Directories

Directory.GetFiles(): Returns an array of file names in the specified directory.

string[] files = Directory.GetFiles(@"C:\MyProject");
foreach (string file in files)
{
    Console.WriteLine(file);
}

Directory.GetDirectories(): Returns an array of directory names in the specified directory.

string[] directories = Directory.GetDirectories(@"C:\MyProject");
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

10. File Path and Directory Path

Path.Combine(): Combines strings into a path.

string path = Path.Combine(@"C:\MyProject", "Documentation");
Console.WriteLine(path);

Path.GetExtension(): Retrieves the extension of the specified path string.

string extension = Path.GetExtension("example.txt");
Console.WriteLine(extension);

Path.GetFileName(): Retrieves the file name and extension of the specified path string.

string fileName = Path.GetFileName(@"C:\MyProject\example.txt");
Console.WriteLine(fileName);

11. Handling Exceptions

It is crucial to handle exceptions, especially when dealing with file and directory operations. Common exceptions include IOException, UnauthorizedAccessException, and ArgumentException.
```
try
{
    File.WriteAllText("example.txt", "Hello, world!");
}
catch (Exception ex)
{
    Console.WriteLine($"An error occurred: {ex.Message}");
}
```

Understanding these file and directory operations in C# is essential for handling data in applications efficiently. The System.IO namespace offers a powerful set of tools to manage I/O tasks effectively. Using these classes and methods appropriately can enhance your application's functionality and robustness.

Summary

Namespaces: System.IO, System.IO.File, System.IO.Directory, System.IO.FileInfo, System.IO.DirectoryInfo
File Operations: Create, Write, Read, Append, Delete, Move
Directory Operations: Create, Delete, Move, Enumerate
File Path and Directory Path: Combine, GetExtension, GetFileName
Exception Handling: Important for robustness

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement File and Directory Operations in C#

Example 1: Creating a Directory

This example demonstrates how to create a directory using C#.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Define the path for the new directory
        string path = @"C:\ExampleDirectory";

        try
        {
            // Create the directory
            Directory.CreateDirectory(path);

            // Output success message
            Console.WriteLine("The directory was created successfully at " + path);
        }
        catch (Exception ex)
        {
            // Output error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define the path: Set the path where you want to create the new directory.
Create the directory: Use Directory.CreateDirectory(path) method to create the directory at specified location.
Exception handling: Use try and catch blocks to handle any exceptions that might occur during directory creation.

Example 2: Check if a Directory Exists

This example checks if a directory exists at a specified path.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Define the path to check
        string path = @"C:\ExampleDirectory";

        // Check if the directory exists
        if (Directory.Exists(path))
        {
            Console.WriteLine("The directory exists.");
        }
        else
        {
            Console.WriteLine("The directory does not exist.");
        }
    }
}

Steps:

Define the path: Specify the path of the directory you want to check.
Check existence: Use Directory.Exists(path) method to determine whether the directory exists or not.
Conditional output: Display a message based on whether the directory exists.

Example 3: Deleting a Directory

This example deletes a directory at a specified path, provided it exists.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Define the path to delete the directory
        string path = @"C:\ExampleDirectory";

        try
        {
            // Check if the directory exists before attempting to delete it
            if (Directory.Exists(path))
            {
                // Delete the directory, including all of its files and subdirectories
                Directory.Delete(path, true);

                // Output a success message
                Console.WriteLine("The directory was deleted successfully at " + path);
            }
            else
            {
                Console.WriteLine("The directory does not exist.");
            }
        }
        catch (Exception ex)
        {
            // Output an error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define the path: Set the path for the directory you want to delete.
Check existence: Confirm the directory exists before deletion using Directory.Exists(path).
Delete directory: Use Directory.Delete(path, true) to delete the directory including all its contents.
Exception handling: Handle exceptions that may arise during the deletion process.

Example 4: Creating a File

This example shows how to create and write text to a file.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Define the file path
        string filePath = @"C:\ExampleDirectory\example.txt";

        try
        {
            // Check if the file already exists
            if (!File.Exists(filePath))
            {
                // Write text to the new file
                using (StreamWriter writer = File.CreateText(filePath))
                {
                    writer.WriteLine("Hello, this is a test file!");
                }

                // Output a success message
                Console.WriteLine("The file was created successfully at " + filePath);
            }
            else
            {
                Console.WriteLine("The file already exists.");
            }
        }
        catch (Exception ex)
        {
            // Output an error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define the file path: Specify the path where you want to create the new file.
Check file existence: Ensure that the file doesn't already exist using File.Exists(filePath).
Create and write to file: Use StreamWriter within a using block to open and write text to the file.
Exception handling: Catch exceptions that might occur during file creation or writing.

Example 5: Reading from a File

This example reads the content of a file into a string.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Define the file path
        string filePath = @"C:\ExampleDirectory\example.txt";

        try
        {
            // Check if the file exists
            if (File.Exists(filePath))
            {
                // Read text from the file
                string content = File.ReadAllText(filePath);

                // Output the content
                Console.WriteLine(content);
            }
            else
            {
                Console.WriteLine("The file does not exist.");
            }
        }
        catch (Exception ex)
        {
            // Output an error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define the file path: Set the path for the file you want to read.
Check file existence: Ensure the file exists using File.Exists(filePath).
Read file content: Use File.ReadAllText(filePath) to read all text from the file.
Output content: Print out the file's content.
Exception handling: Handle exceptions related to file reading.

Example 6: Copying a File

This example copies a file from one location to another.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Original file path
        string originalPath = @"C:\ExampleDirectory\example.txt";

        // Destination file path
        string destinationPath = @"C:\ExampleDirectory\example_copy.txt";

        try
        {
            // Check if the source file exists
            if (File.Exists(originalPath))
            {
                // If the destination file already exists, delete it
                if (File.Exists(destinationPath))
                    File.Delete(destinationPath);

                // Copy file from source to destination
                File.Copy(originalPath, destinationPath);

                // Output success message
                Console.WriteLine("The file was copied successfully to " + destinationPath);
            }
            else
            {
                Console.WriteLine("The original file does not exist.");
            }
        }
        catch (Exception ex)
        {
            // Output error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define source and destination file paths.
Check source file existence: Verify that the original file exists before copying.
Remove existing copy (if necessary): Delete the destination file if it already exists so as to avoid overwriting errors.
Copy file: Use File.Copy(originalPath, destinationPath) to copy the file to the new location.
Exception handling: Catch exceptions that could occur during file copying.

Example 7: Moving a File

This example moves a file from one location to another.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Original file path
        string originalPath = @"C:\ExampleDirectory\example.txt";

        // Destination file path
        string destinationPath = @"C:\NewDirectory\example_move.txt";

        try
        {
            // Ensure the original file exists
            if (File.Exists(originalPath))
            {
                // Ensure the destination directory exists, else create it
                string directoryPath = Path.GetDirectoryName(destinationPath);
                if (!Directory.Exists(directoryPath))
                    Directory.CreateDirectory(directoryPath);

                // Move file from source to destination
                File.Move(originalPath, destinationPath);

                // Output success message
                Console.WriteLine("The file was moved successfully to " + destinationPath);
            }
            else
            {
                Console.WriteLine("The original file does not exist.");
            }
        }
        catch (Exception ex)
        {
            // Output error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define source and destination file paths.
Check if the source file exists: Ensure the source file is present before attempting to move it.
Ensure destination directory exists: Verify that the destination directory exists using Directory.Exists(). If not, create it with Directory.CreateDirectory().
Move file: Use File.Move(originalPath, destinationPath) to move the file to a new location.
Exception handling: Catch and handle any possible exceptions during the move process.

Example 8: Listing Files in a Directory

This example lists all files in a specified directory.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Path to the directory to list files from
        string directoryPath = @"C:\ExampleDirectory";

        try
        {
            // Ensure the directory exists
            if (Directory.Exists(directoryPath))
            {
                // Get array of all files in the directory
                string[] files = Directory.GetFiles(directoryPath);

                // Iterate through the files and display their names
                foreach (string file in files)
                {
                    Console.WriteLine(file);
                }
            }
            else
            {
                Console.WriteLine("The directory does not exist.");
            }
        }
        catch (Exception ex)
        {
            // Output an error message
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }
}

Steps:

Define directory path: Specify the path to the directory that contains the files.
Check if the directory exists: Ensure the directory exists using Directory.Exists(directoryPath).
Get files: Retrieve an array of filenames in the directory using Directory.GetFiles(directoryPath).
Iterate and output: Loop through the filenames and print each one.
Exception handling: Catch exceptions that might occur when fetching the files.

Example 9: Listing Subdirectories

This example lists all subdirectories in a specified directory.

Top 10 Interview Questions & Answers on File and Directory Operations in C#

1. How can I read a text file in C#?

Answer:
To read a text file in C#, you can use the System.IO.File.ReadAllText() method, or if you need line-by-line reading, System.IO.File.ReadAllLines(). For more complex scenarios, you might want to use System.IO.StreamReader.

string fileContent = System.IO.File.ReadAllText("path/to/your/file.txt");
string[] lines = System.IO.File.ReadAllLines("path/to/your/file.txt");

using (var sr = new System.IO.StreamReader("path/to/your/file.txt"))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

2. How to write text to a file in C#?

Answer:
You can write text to a file using System.IO.File.WriteAllText() for overwriting, and System.IO.File.AppendAllText() for appending. Alternatively, use System.IO.StreamWriter for more control.

System.IO.File.WriteAllText("path/to/your/file.txt", "Hello World!");

System.IO.File.AppendAllText("path/to/your/file.txt", "This is an appended line.");

using (var sw = new System.IO.StreamWriter("path/to/your/file.txt", true))
{
    sw.WriteLine("Another line added.");
}

3. How do I create a directory in C#?

Answer:
Use Directory.CreateDirectory() to create a directory.

string path = @"C:\Your\New\Folder";
System.IO.Directory.CreateDirectory(path);

4. How can I check if a directory exists in C#?

Answer:
To check if a directory exists, use Directory.Exists().

string path = @"C:\Existing\Folder";
bool exists = System.IO.Directory.Exists(path);
Console.WriteLine(exists ? "Directory exists" : "Directory does not exist");

5. How to delete a file in C#?

Answer:
Delete a file using File.Delete().

string filePath = "path/to/your/file.txt";
if (System.IO.File.Exists(filePath)) 
{
    System.IO.File.Delete(filePath);
}
else 
{
    Console.WriteLine("File does not exist.");
}

6. How can I copy files and directories in C#?

Answer:
Use File.Copy() for copying files, and Directory.Copy() for copying directories.

string sourcePath = "path/to/source/file.txt";
string destinationPath = "path/to/destination/file.txt";
System.IO.File.Copy(sourcePath, destinationPath, true); // The third parameter allows overwriting.

string sourceDir = @"C:\SourceFolder";
string destDir = @"C:\DestinationFolder";
System.IO.Directory.Copy(sourceDir, destDir, true);

7. How to move files and directories in C#?

Answer:
Use File.Move() to move files and Directory.Move() to move directories.

string originalFilePath = "path/to/original/file.txt";
string targetFilePath = "path/to/target/file.txt";
System.IO.File.Move(originalFilePath, targetFilePath);

string originalDirPath = @"C:\OriginalFolder";
string targetDirPath = @"C:\TargetFolder";
System.IO.Directory.Move(originalDirPath, targetDirPath);

8. How can I list all files in a directory?

Answer:
Retrieve a list of files in a directory by using Directory.GetFiles().

string directoryPath = @"C:\Your\Folder";
string[] files = System.IO.Directory.GetFiles(directoryPath);

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

9. How do I recursively delete a directory in C#?

Answer:
Recursively deleting a directory can be achieved with Directory.Delete() by setting the second parameter (recursive) to true.

string dirPath = @"C:\Your\Folder";
if (System.IO.Directory.Exists(dirPath))
{
    System.IO.Directory.Delete(dirPath, true);
}
else
{
    Console.WriteLine("Directory does not exist.");
}

10. How can I find out the size of a file in C#?

Answer:
You can check the size of a file by getting the Length property of the FileInfo class.

File And Directory Operations In C# Complete Guide