File I/O in .NET - MSDN Documentation

File Input and Output (I/O) in .NET

This document provides a comprehensive guide to performing file input and output operations in .NET. Learn how to read from, write to, and manage files and directories efficiently and securely.

Core Concepts

File Streams: Understanding how to use classes like FileStream to read and write raw bytes.
Text Files: Working with text-based files using classes like StreamReader, StreamWriter, and the static methods in the File class.
File and Directory Management: Operations such as creating, deleting, copying, moving files and directories using the File and Directory classes.
Path Manipulation: Using the Path class for cross-platform path operations.
Asynchronous Operations: Performing I/O operations without blocking the main thread using asynchronous methods.

Key Classes and Namespaces

The primary classes and namespaces for file I/O reside in the System.IO namespace.

System.IO.File: Static methods for common file operations (copy, delete, move, open, read, write).
System.IO.Directory: Static methods for common directory operations (create, delete, move, enumerate).
System.IO.Path: Static methods for manipulating path strings.
System.IO.StreamReader: Reads characters from a byte stream in a particular encoding.
System.IO.StreamWriter: Writes characters to a stream in a particular encoding.
System.IO.FileStream: Provides a stream for a file, supporting both synchronous and asynchronous read and write operations.
System.IO.FileInfo: Provides instance methods for the creation, deletion, moving, and opening of files, and aids in their creation.
System.IO.DirectoryInfo: Provides instance methods for the creation, deletion, moving, and enumeration of directories and subdirectories.

For a detailed list, refer to the .NET API Browser for System.IO.

Code Examples

Reading Text from a File

Using StreamReader:

using System;
using System.IO;

public class ReadTextFile
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt";
        try
        {
            using (StreamReader sr = new StreamReader(filePath))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"The file could not be read: {e.Message}");
        }
    }
}

Alternatively, using the static File.ReadAllText():

string content = File.ReadAllText("myFile.txt");
Console.WriteLine(content);

Writing Text to a File

Using StreamWriter:

using System;
using System.IO;

public class WriteTextFile
{
    public static void Main(string[] args)
    {
        string filePath = "output.txt";
        try
        {
            using (StreamWriter sw = new StreamWriter(filePath))
            {
                sw.WriteLine("This is the first line.");
                sw.WriteLine("This is the second line.");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"The file could not be written: {e.Message}");
        }
    }
}

To append to a file, use new StreamWriter(filePath, true) or File.AppendAllText().

File.AppendAllText("output.txt", "This line is appended.");

Checking if a File Exists

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

Creating a Directory

string directoryPath = "MyNewFolder";
if (!Directory.Exists(directoryPath))
{
    Directory.CreateDirectory(directoryPath);
    Console.WriteLine($"Directory '{directoryPath}' created.");
}

Best Practices and Considerations

Use using statements: Always use using statements for streams and file handles to ensure resources are properly disposed of.
Error Handling: Implement robust error handling (e.g., try-catch blocks) to manage potential exceptions like FileNotFoundException, UnauthorizedAccessException, etc.
Path Separators: Use Path.Combine() for constructing file paths to ensure cross-platform compatibility.
File Locking: Be aware of file locking mechanisms, especially in multi-threaded applications.
Encoding: Specify the correct encoding when reading or writing text files to avoid character corruption. The default is typically UTF-8.
Asynchronous I/O: For performance-critical applications, especially in UI or web scenarios, leverage asynchronous file operations (e.g., ReadAsync, WriteAsync) to prevent blocking.