In this article, we will delve into the methods to save a list to a text file using two C# classes: StreamWriter and File. We will also discuss which class best aligns with the specific requirements for file operations.
Without further ado, let’s dive in!
Preparation
Before we move on to saving lists to files, we will configure a few things that we will need in all later examples. We have to indicate where we want to save our file and what it should be called:
var tempPath = Path.GetTempPath(); var fileName = "CodeMazeAnimals.txt"; var path = Path.Combine(tempPath, fileName);
First, we call Path.GetTempPath() to get the path to the system-defined temp directory. Next, using Path.Combine(), we generate a file name, located in the temp directory called CodeMazeAnimals.txt. For more insight into the location returned by Path.GetTempPath() please see the Microsoft documentation.
Save a List Using the StreamWriter Class in C#
One effective method for saving a list to a file in C# is the usage of the StreamWriter class. This class comes from the System.IO namespace and is designed for writing text data to files.
Let’s have a look at an example of using StreamWriter to write a list of animals in a file:
var animals = new List<string> { "Dog", "Cat", "Parrot" };
using var sw = new StreamWriter(path);
foreach (var animal in animals)
{
sw.WriteLine(animal);
}
The code snippet creates list of animals and then opens a write stream to our CodeMazeAnimals.txt file. Lastly, we iterate through animal list, writing each one as a separate line entry in the file via the StreamWriter.WriteLine() call.
The file content looks like this after we execute our code:
Dog Cat Parrot
When exploring examples of the StreamWriter class in C#, we frequently notice that developers declare it with a using statement or declaration. This is because StreamWriter implements the IDisposable interface. The using declaration ensures the calling of Dispose() when the object exits scope. This has the added benefit of flushing and closing the stream automatically.
When we use StreamWriter to save a list, it not only allows us to write all the elements of the list into a newly created file but also offers the flexibility to open an existing file and append new elements to it. The code to modify an existing file is quite similar to the previous example:
var newAnimals = new List<string> { "Hamster" };
using var sw = new StreamWriter(path, append: true);
foreach (var animal in animals)
{
sw.WriteLine(animal);
}
The only difference is that we need to add a new parameter while creating the StreamWriter class. The parameter is called append and by setting it to true, we indicate that we will be adding additional content to the file.
It’s worth mentioning that we can use the StreamWriter in an asynchronous way:
var animals = new List<string> { "Dog", "Cat", "Parrot" };
await using var sw = new StreamWriter(path);
foreach (var animal in animals)
{
await sw.WriteLineAsync(animal);
}
This allows for non-blocking operations, enhancing the performance of the application. This is accomplished through the WriteLineAsync() method. This method will write to the file asynchronously. We use the await using statement to properly dispose of the StreamWriter instance asynchronously.
This code produces the same output we had synchronously:
Dog Cat Parrot
Save a List Using the File Class in C#
The File class offers a simple approach to both saving a list to a file and appending it to an existing file.
Let’s illustrate this simplicity with an example:
var animals = new List<string> { "Dog", "Cat", "Parrot" };
File.WriteAllLines(path, animals);
var newAnimals = new List<string> { "Hamster" };
File.AppendAllLines(path, newAnimals);
To write a list to a file, we can use the File.WriteAllLines() method, which creates a new file and writes the list elements to it, each as a new line.
To append items from a list to an existing file, we use the File.AppendAllLines() method. These methods handle opening, writing, and closing the file automatically.
This code snippet outputs a list of all animals, specified both in animals and newAnimals lists:
Dog Cat Parrot Hamster
Similar to StreamWriter, the File class also provides asynchronous versions of its methods:
await File.WriteAllLinesAsync(path, animals); await File.AppendAllLinesAsync(path, newAnimals);
Choosing the Right Method
If it is so simple to write a list to a file with the usage of the File class, do we still need the StreamWriter in C#? The answer is: yes!
While the File class is ideal for straightforward, one-time file operations like writing or appending short texts, the StreamWriter excels in performance and customization for advanced tasks. Whenever we want to perform a larger, more complex writing task, we should use the StreamWriter. This option offers finer control and more efficient handling of large amounts of data.
Conclusion
