Complete Guide to Appending Text to Files Using StreamWriter in C#

Introduction

File operations are common tasks in C# programming. Many developers encounter a typical issue when handling file writing: each time the program runs, file content gets overwritten instead of being appended. Based on actual programming problems and solutions, this article deeply explores how to correctly implement file appending functionality using StreamWriter.

Problem Analysis

Consider the following common code scenario:

StreamWriter file2 = new StreamWriter(@"c:\file.txt");
file2.WriteLine(someString);
file2.Close();

This code overwrites file content each time it executes, resulting in only the last written data being visible. This occurs because, by default, the StreamWriter constructor opens files in overwrite mode.

Append Mode in StreamWriter

The StreamWriter class provides an overloaded constructor that allows specifying whether to append to an existing file:

new StreamWriter("c:\\file.txt", true);

The second parameter is a boolean value. When set to true, StreamWriter opens the file in append mode. If the file doesn't exist, a new file is created; if the file exists, new content is added to the end of the file.

Modern C# Syntax Improvements

In C# 4.0 and later versions, named parameters can be used to improve code readability:

new StreamWriter("c:\\file.txt", append: true);

This writing style clearly expresses intent, making the code easier to understand and maintain.

Complete Code Example

In practical applications, it's recommended to use using statements to ensure proper resource disposal:

using (StreamWriter writer = new StreamWriter("c:\\file.txt", append: true))
{
    writer.WriteLine("This is the text line to append");
    writer.WriteLine("This is another line of text");
}

The using statement automatically calls the Dispose method, ensuring the file stream is properly closed, even if exceptions occur.

Alternative Approach: Using FileStream

Besides using StreamWriter directly, file appending can also be achieved through FileStream:

using (FileStream fs = new FileStream(fileName, FileMode.Append, FileAccess.Write))
using (StreamWriter sw = new StreamWriter(fs))
{
    sw.WriteLine(something);
}

This method provides finer control, with FileMode.Append ensuring the file opens in append mode and FileAccess.Write specifying write permissions.

Convenient Methods of the File Class

The .NET Framework also provides static methods in the File class for file appending:

// Append single line of text
File.AppendAllText("file.txt", "Text to append" + Environment.NewLine);

// Append multiple lines of text
string[] lines = { "First line", "Second line", "Third line" };
File.AppendAllLines("file.txt", lines);

These methods internally handle stream opening and closing, suitable for simple appending scenarios.

Asynchronous File Operations

For applications requiring high performance, asynchronous methods can be considered:

using (StreamWriter writer = new StreamWriter("file.txt", append: true))
{
    await writer.WriteLineAsync("Asynchronously written text");
}

Asynchronous operations can avoid blocking the main thread, improving application responsiveness.

Error Handling and Best Practices

In practical applications, appropriate error handling should be included:

try
{
    using (StreamWriter writer = new StreamWriter("file.txt", append: true))
    {
        writer.WriteLine("Safely written text");
    }
}
catch (IOException ex)
{
    Console.WriteLine($"File operation error: {ex.Message}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"Permission error: {ex.Message}");
}

Performance Considerations

When frequently appending large amounts of data, the following optimization strategies can be considered:

• Batch writing: Accumulate a certain amount of data before performing write operations
• Buffer management: Appropriately adjust StreamWriter's buffer size
• File locking: Properly handle file access conflicts in multi-threaded environments

Conclusion

By correctly using StreamWriter's append parameter, file content can be easily appended instead of overwritten. The methods introduced in this article cover various aspects from basic usage to advanced techniques, providing C# developers with a complete file appending solution. The choice of method depends on specific application scenarios and performance requirements, but using using statements and appropriate error handling are best practices that should be followed in any situation.