C# - Working With Files

Working With Files in C#

Working with files is a common task in software development, and C# provides a rich set of classes and methods to handle file operations efficiently and safely. This detailed guide covers everything from the basics of file I/O to advanced techniques, including reading, writing, manipulating files and directories, error handling, asynchronous operations, and best practices.

1. Introduction to File Handling in C#

File handling refers to the process of reading data from and writing data to files stored on disk or other persistent storage. C# provides the System.IO namespace, which contains essential classes like File, FileInfo, Directory, DirectoryInfo, Stream, StreamReader, StreamWriter, FileStream, and others for working with files and directories.

Key Concepts

• File: A container in the file system that stores data.
• Directory: A folder that contains files or other directories.
• Stream: An abstraction for reading/writing bytes to/from a file or other data sources.
• Path: A string that specifies the location of a file or directory.

2. Important Classes in System.IO Namespace

File and FileInfo

The File class provides static methods for file operations (like create, delete, copy, move, read, write). FileInfo is an instance-based class offering similar functionality with additional file metadata.

Directory and DirectoryInfo

Used to manipulate directories and their contents.

FileStream

Provides a stream for reading and writing bytes to files. Used for more controlled file operations.

StreamReader and StreamWriter

Specialized for reading and writing text files conveniently.

Path

Helps in manipulating strings representing file paths safely and platform-independently.

3. Working with Files - Basic Operations

3.1 Creating and Writing to a File

There are multiple ways to create and write to files in C#:

Using File.WriteAllText

string path = @"C:\temp\example.txt";
string content = "Hello, World!";

File.WriteAllText(path, content);

This method creates the file if it doesn’t exist or overwrites it if it does.

Using StreamWriter

using (StreamWriter writer = new StreamWriter(path))
{
    writer.WriteLine("First line");
    writer.WriteLine("Second line");
}

StreamWriter is useful for writing lines and appending content.

3.2 Reading from a File

Using File.ReadAllText

string text = File.ReadAllText(path);
Console.WriteLine(text);

Using StreamReader

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

4. File Existence and Information

Checking if a File Exists

if (File.Exists(path))
{
    Console.WriteLine("File exists.");
}
else
{
    Console.WriteLine("File does not exist.");
}

Getting File Information Using FileInfo

FileInfo fileInfo = new FileInfo(path);
Console.WriteLine($"File Size: {fileInfo.Length} bytes");
Console.WriteLine($"Created On: {fileInfo.CreationTime}");
Console.WriteLine($"Last Modified: {fileInfo.LastWriteTime}");

5. Deleting, Copying, and Moving Files

Deleting a File

if (File.Exists(path))
{
    File.Delete(path);
    Console.WriteLine("File deleted.");
}

Copying a File

string destPath = @"C:\temp\example_copy.txt";
File.Copy(path, destPath, overwrite: true);

Moving or Renaming a File

string newPath = @"C:\temp\example_renamed.txt";
File.Move(path, newPath);

6. Working with Directories

Creating Directories

string dirPath = @"C:\temp\myfolder";
Directory.CreateDirectory(dirPath);

Checking if Directory Exists

if (Directory.Exists(dirPath))
{
    Console.WriteLine("Directory exists.");
}

Listing Files in a Directory

string[] files = Directory.GetFiles(dirPath);

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

Deleting Directories

if (Directory.Exists(dirPath))
{
    Directory.Delete(dirPath, recursive: true);
}

7. Using FileStream for Advanced File Operations

FileStream gives you control over how to read and write bytes, useful for binary files or when performance and buffering options matter.

Opening a FileStream

using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
    // Work with the stream here
}

Writing Bytes to a File

byte[] data = new byte[] { 1, 2, 3, 4, 5 };
using (FileStream fs = new FileStream(path, FileMode.Create))
{
    fs.Write(data, 0, data.Length);
}

Reading Bytes from a File

byte[] buffer = new byte[1024];
using (FileStream fs = new FileStream(path, FileMode.Open))
{
    int bytesRead = fs.Read(buffer, 0, buffer.Length);
    Console.WriteLine($"Read {bytesRead} bytes.");
}

8. File Access Modes

The FileMode and FileAccess enums define how files are opened:

• FileMode options: CreateNew, Create, Open, OpenOrCreate, Append, Truncate
• FileAccess options: Read, Write, ReadWrite

Example: OpenOrCreate with ReadWrite

using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
    // read and write code
}

9. Handling Exceptions When Working With Files

File operations can fail due to various reasons like missing permissions, files in use, path errors, or disk issues. Always use exception handling.

Common Exceptions

• IOException: General I/O errors
• UnauthorizedAccessException: Insufficient permissions
• FileNotFoundException: File not found
• DirectoryNotFoundException: Directory not found
• PathTooLongException: Path exceeds max length

Example: Safe File Reading

try
{
    string text = File.ReadAllText(path);
    Console.WriteLine(text);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine("File not found: " + ex.Message);
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Access denied: " + ex.Message);
}
catch (IOException ex)
{
    Console.WriteLine("I/O error: " + ex.Message);
}

10. Working With Temporary Files

C# provides ways to create and manage temporary files.

Using Path.GetTempFileName()

string tempFile = Path.GetTempFileName();
Console.WriteLine("Temp file created at: " + tempFile);

Deleting Temporary Files

File.Delete(tempFile);

11. Asynchronous File Operations

Modern applications often require non-blocking file I/O for better performance and responsiveness. C# supports asynchronous file operations with methods ending in Async.

Asynchronous Reading

using System.Threading.Tasks;

async Task ReadFileAsync(string filePath)
{
    using (StreamReader reader = new StreamReader(filePath))
    {
        string content = await reader.ReadToEndAsync();
        Console.WriteLine(content);
    }
}

Asynchronous Writing

async Task WriteFileAsync(string filePath, string content)
{
    using (StreamWriter writer = new StreamWriter(filePath))
    {
        await writer.WriteAsync(content);
    }
}

12. File Encoding

When reading or writing text files, encoding is important. The default is UTF-8, but you can specify other encodings.

using (StreamWriter writer = new StreamWriter(path, false, System.Text.Encoding.UTF8))
{
    writer.WriteLine("Text with UTF-8 encoding");
}

13. Monitoring File Changes

The FileSystemWatcher class lets you monitor changes in files or directories.

Example

FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = @"C:\temp";
watcher.Filter = "*.txt";

watcher.Changed += (s, e) => Console.WriteLine($"File changed: {e.FullPath}");
watcher.EnableRaisingEvents = true;

14. Best Practices for Working With Files

• Always close streams: Use using blocks to ensure proper disposal.
• Validate paths: Use Path class methods to sanitize and build paths.
• Handle exceptions gracefully: Anticipate and catch exceptions.
• Use asynchronous methods: For I/O-bound operations to improve responsiveness.
• Manage file locks: Avoid conflicts when multiple processes access files.
• Prefer relative paths: For portability.
• Secure file access: Avoid exposing sensitive file paths or data.

Working with files in C# involves understanding the classes in the System.IO namespace, how to read, write, copy, move, and delete files safely, how to handle exceptions, and how to implement asynchronous operations. Proper use of these techniques helps build robust, maintainable applications that interact with the file system effectively.