C# File Handling

Learn ways to handle files. Many methods from the System.IO namespace are available.
File. A message is carved into rock. This ancient city is full of life and beauty. In one moment the city is destroyed. But that message remains.
Consider a computer. Data stored in a file lasts longer than that on memory. A file is persistent. In C# we handle files with System.IO.
StreamReader. For text files, StreamReader and StreamWriter are often the most useful types. We use StreamReader in a "using" block (a special syntax form).StreamReader

Tip: Syntax forms like the using-statement are useful. They allow automatic cleanup of resources.


ReadLine: This is a method on StreamReader. It returns null if no further data is available in the file.

ReadLine, ReadLineAsync
C# program that uses StreamReader, ReadLine using System.IO; class Program { static void Main() { // Read every line in the file. using (StreamReader reader = new StreamReader("file.txt")) { string line; while ((line = reader.ReadLine()) != null) { // Do something with the line. string[] parts = line.Split(','); } } } }
StreamWriter. This class writes strings or append strings to a text file. We can write numbers or the textual representation of anything. It also uses a "using" block.StreamWriter
C# program that uses StreamWriter using System.IO; class Program { static void Main() { // Create or open file and write line to it. // ... If file exists, it contents are erased before writing. using (var writer = new StreamWriter(@"C:\programs\example.txt")) { writer.WriteLine("HELLO"); } } }
ReadAllText. This program uses this method to load in the file "file.txt" on the C: volume. Then it prints the contents of the file. The data is now stored in a string object.File.ReadAllText

Tip: ReadAllText is the easiest way to put a file into a string. It is part of the System.IO namespace.

C# program that uses ReadAllText using System; using System.IO; class Program { static void Main() { string file = File.ReadAllText("C:\\file.txt"); Console.WriteLine(file); } }
ReadAllLines. Here we read all the lines from a file and place them in an array. The code reads lines from "file.txt" and uses a foreach-loop on them. This is efficient code.File.ReadAllLines
C# program that uses ReadAllLines using System.IO; class Program { static void Main() { // Read in every line in specified file. // ... This will store all lines in an array in memory. string[] lines = File.ReadAllLines("file.txt"); foreach (string line in lines) { // Do something with the line. if (line.Length > 80) { // Important code. } } } }
Count lines. We count the number of lines in a file with few lines of code. The example here is a bit slow. But it works. It references the Length property.Line Count
C# program that counts lines using System.IO; class Program { static void Main() { // Another method of counting lines in a file. // ... This is not the most efficient way. // ... It counts empty lines. int lineCount = File.ReadAllLines("file.txt").Length; } }
Query. Does a line containing a specific string exist in the file? Maybe we want to see if a name or location exists in a line in the file. We use LINQ to find any matching line.Count
C# program that uses LINQ on file using System.IO; using System.Linq; class Program { static void Main() { // See if line exists in a file. // ... Use a query expression to count matching lines. // ... If one matches, the bool is set to true. bool exists = (from line in File.ReadAllLines("file.txt") where line == "Some line match" select line).Count() > 0; } }
ReadLines. This method does not immediately read in every line. It instead reads lines only as they are needed. We use it in a foreach-loop.File.ReadLinesForeach
WriteAllLines. We can write an array to a file. When we are done within-memory processing, we often need to write the data to disk.
C# program that writes array to file using System.IO; class Program { static void Main() { // Write a string array to a file. string[] stringArray = new string[] { "cat", "dog", "arrow" }; File.WriteAllLines("file.txt", stringArray); } } Results: file.txt cat dog arrow
WriteAllText. A simple method, File.WriteAllText receives two arguments. It receives the path of the output file, and the exact string contents of the text file.

Note: The file is created if it does not exist, or replaced with a new file if it does exist (no appends ever occur).

C# program that uses WriteAllText using System.IO; class Program { static void Main() { File.WriteAllText("C:\\perls.txt", "Dot Net Perls"); } }
AppendAllText. We could read in a file, append to that in memory, and then write it out completely again. That is slow. Its more efficient to use an append.

Argument 1: The first argument to File.AppendAllText is the name of the file we wish to append text to.

Argument 2: The second argument is the string we wish to append to the file—we must add a newline at the end if we want to write a line.

Internals: Inspected in IL Disassembler: AppendAllText internally calls StreamWriter, with the second parameter "append" set to true.

Note: If the file already exists when the program starts, the file will be appended to. Otherwise, a new file is created.

C# program that uses File.AppendAllText using System.IO; class Program { static void Main() { // Use AppendAllText to write one line to the text file. File.AppendAllText("C:\\perls.txt", "first part\n"); // The file now has a newline at the end, so write another line. File.AppendAllText("C:\\perls.txt", "second part\n"); // Write a third line. string third = "third part\n"; File.AppendAllText("C:\\perls.txt", third); } } Output first part second part third part Output (repeat run): first part second part third part first part second part third part
ReadAllBytes. We use File.ReadAllBytes to read an image (a PNG) into memory. With this code, we could cache an image in memory. It outperforms reading the image in each time.File.ReadAllBytesFile.WriteAllBytes: Compress
C# program that caches binary file static class ImageCache { static byte[] _logoBytes; public static byte[] Logo { get { // Returns logo image bytes. if (_logoBytes == null) { _logoBytes = File.ReadAllBytes("Logo.png"); } return _logoBytes; } } }
Read optimization, ReadLine. Suppose we have a text file with many lines. We could read the file with File.ReadAllLines, but using StreamReader and ReadLine is another option.

Here: We create a test file with 1 million lines, then read it in with StreamReader line-by-line, and also with File.ReadAllLines.

Results: Using ReadLine with StreamReader is faster. For files with many lines, it is worth reading in the lines iteratively.

C# program that benchmarks reading by lines using System; using System.Diagnostics; using System.IO; class Program { static void CreateFileWithManyLines() { // Create temporary file for benchmark. using (StreamWriter writer = new StreamWriter(@"C:\programs\file.txt")) { for (int i = 0; i < 1000000; i++) { writer.WriteLine("x"); } } } const int _max = 10; static void Main() { CreateFileWithManyLines(); // Version 1: use StreamReader and read in each line. var s1 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (Method1() == 0) { return; } } s1.Stop(); // Version 2: use File.ReadAllLines to get entire string array. var s2 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (Method2() == 0) { return; } } s2.Stop(); Console.WriteLine(s1.Elapsed.TotalMilliseconds.ToString("0.00 ms")); Console.WriteLine(s2.Elapsed.TotalMilliseconds.ToString("0.00 ms")); } static int Method1() { int count = 0; using (StreamReader reader = new StreamReader(@"C:\programs\file.txt")) { while (true) { string line = reader.ReadLine(); if (line == null) { break; } count++; } } return count; } static int Method2() { string[] array = File.ReadAllLines(@"C:\programs\file.txt"); return array.Length; } } Output 219.53 ms StreamReader, ReadLine 1212.43 ms File.ReadAllLines
Path. Before any file can be opened, it must be addressed. File paths are complex. They include the volume, directory, name and extension.Path
Directory. We can manipulate directories on the file system with System.IO. The Directory type, and its static methods, is necessary for this.DirectoryDirectory: CreateDirectory: Get FilesDirectory: Size
FileInfo. We can get information about a file from the file system with FileInfo. This does not load the entire file into memory. It just reads stored stats.FileInfoFileInfo: Length
HTML, XML. Some files have lots of brackets and tags. These are usually HTML or XML files. We could write custom methods for each program, but standardized approaches exist.HTML, XML
TextReader. The TextReader and TextWriter types form the base class that other, more useful types derive from. Usually they are not useful on their own.TextReaderTextWriter
Binary. BinaryReader and BinaryWriter make reading or writing a binary file much easier. These types introduce a level of abstraction over the raw data.BinaryReaderBinaryWriter
Actions. We copy, delete, rename or get time information about files. These actions are available through the File type and the FileInfo type.File.CopyFile.DeleteFile.ExistsFile.GetLastWriteTimeUtcFile.MoveFile.OpenFile.Replace
Stream. There are many forms of streams. Sometimes leaving a file on the disk would impact performance or stability in a negative way. In these cases, consider MemoryStream.StreamFileStreamMemoryStreamBaseStreamBufferedStream

Seek: We can seek to a specific location in a file with the Seek method. Seek is useful with large binary files.

WebClient. Not every file we want to use is local. A file may be remote. We may need to access the network to download a file from a server.WebClientHttpClient
Office. It is common to need to control Microsoft Excel with C# code. We introduce a fast approach. This material may be outdated, but it still helps on many systems.ExcelWord
CSV files. These are text-based databases. With the System.IO namespace, we can read them into a C# program. Sadly the TextFieldParser is slow.TextFieldParser: Parse CSVCSV: Separate Files
Equality. How can we tell if 2 files are exactly equal? Unfortunately, the file system's metadata is not sufficient. A method that compares each byte is effective.File Equals
Research. The performance of file handling is an important part of computer programming. Often, optimizing how files are used is the most effective way to make a program faster.

Quote: One of the most significant sources of inefficiency is unnecessary input/output (I/O) (Code Complete).

Quote: We can build small and fast storage, or large and slow storage, but not storage that is both large and fast (Compilers: Principles, Techniques and Tools).

A final reminder. Even with the helpful types provided in the .NET Framework, file handling is fraught with errors. We must account for disk errors and invalid data.
© 2007-2019 Sam Allen. Every person is special and unique. Send bug reports to
Dot Net Perls