Welcome to this lesson on reading files with StreamReader. Building upon our foundational knowledge of handling text files, this lesson will guide you through the techniques of utilizing the tools provided by C#'s System.IO.StreamReader to read files. These methods are crucial for handling varying file sizes efficiently and managing memory use effectively. By the end of this lesson, you'll be able to read entire files, specific portions, and process files in manageable chunks, granting you flexible control over text data processing.

Before we jump into reading files, let's review the example file that we will work with:

Plain text
Copy to clipboard
1Hi!
2This file contains some sample example text to use to test how the read method works.
3Let's do some programming!

This file contains multiple lines of varied lengths.

The StreamReader class in C# is part of the System.IO namespace and is designed for reading characters from byte streams in a specified encoding. It provides methods and properties for textual file reading, allowing you to read data from files asynchronously and synchronously.

To read a file's entire content character by character, we can open the file using StreamReader and utilize the Read() method, which reads the next character in the stream and advances the position by one character at a time.

Here is how to read a file completely character by character using a loop:

C#
Copy to clipboard
1using System;
2using System.IO;
3
4class Program
5{
6    static void Main(string[] args)
7    {
8        string filePath = "example.txt";
9
10        using (var reader = new StreamReader(filePath))
11        {
12            while (!reader.EndOfStream)
13            {
14                int ch = reader.Read();
15                Console.Write((char)ch);
16            }
17        }
18    }
19}

• The using block manages the StreamReader object's lifespan, ensuring it is closed and disposed of properly after the reading operations. This is crucial to release system resources promptly and avoid potential file locks.
• The Read() method reads a character from the file and returns its integer representation, which is the ASCII value of that character. For instance, reading the character 'A' would return the integer 65. In the loop, this integer is converted back to a character using (char), by which we get the original character. The loop continues until the EndOfStream property returns true, indicating the end of the file has been reached.

The expected output is:

Plain text
Copy to clipboard
1Hi!
2This file contains some sample example text to use to test how the read method works.
3Let's do some programming!

This approach suits situations where processing files one character at a time is necessary or preferred. It provides a straightforward way to read entire files while maintaining resource efficiency, making StreamReader a versatile option for file manipulation in C#.

In many situations, you may only need to read a specific number of characters rather than the entire file. This can be accomplished by utilizing Read() inside a loop that iterates a set number of times based on the count of characters you'd like to read.

C#
Copy to clipboard
1using System;
2using System.IO;
3
4class Program
5{
6    static void Main(string[] args)
7    {
8        string filePath = "example.txt";
9        
10        using (var reader = new StreamReader(filePath))
11        {
12            int charactersToRead = 10;
13            while (!reader.EndOfStream && charactersToRead > 0)
14            {
15                int ch = reader.Read();
16                Console.Write((char)ch);
17                charactersToRead--;
18            }
19        }
20    }
21}

The loop continues until the specified number of characters (in this case, 10) are read or until the end of the file is reached, whichever comes first.

The expected output is:

Plain text
Copy to clipboard
1Hi!
2This f

This method is especially useful for preliminary processing or debugging large files.

Sequential reading in file handling refers to the process of reading a file's contents in a predefined, orderly manner—part-by-part—without restarting from the beginning each time. For instance, by using loops in combination with the Read() method, each subsequent read operation continues from where the last one concluded. This approach is exceptionally beneficial when dealing with large files or when you require distinct segments from a file.

Here's an example:

C#
Copy to clipboard
1using System;
2using System.IO;
3
4class Program
5{
6    static void Main(string[] args)
7    {
8        string filePath = "example.txt";
9        
10        using (var reader = new StreamReader(filePath))
11        {
12            Console.WriteLine("First 10 characters:");
13            
14            // First segment: read the initial 10 characters
15            int firstReadLength = 10;
16            int ch;
17            while (!reader.EndOfStream && firstReadLength > 0)
18            {
19                ch = reader.Read();
20                Console.Write((char)ch);
21                firstReadLength--;
22            }
23
24            // Second segment: read the next 10 characters
25            Console.WriteLine("\n\nNext 10 characters:");
26            int nextReadLength = 10;
27            while (!reader.EndOfStream && nextReadLength > 0)
28            {
29                ch = reader.Read();
30                Console.Write((char)ch);
31                nextReadLength--;
32            }
33        }
34    }
35}

This program reads and prints the first 10 characters from the file, then moves forward to read the next set of 10 characters. The StreamReader maintains its position within the file, allowing seamless sequential access to subsequent portions.

Expected output would be:

Plain text
Copy to clipboard
1First 10 characters:
2Hi!
3This f
4
5Next 10 characters:
6ile contai

This technique is advantageous when you only need specific sections of a file or when you want to process large files in smaller chunks, thereby reducing memory consumption and improving performance. It also facilitates better data manipulation in scenarios where progressive reading is required.

In this lesson, you learned how to effectively use the C# System.IO.StreamReader class for various file reading tasks. We covered reading entire files, specific portions, and processing large files efficiently by chunk reading. These techniques provide you with control and flexibility in handling text data.

Experiment with these methods using different files to strengthen your understanding of file manipulation in C#. Keep practicing to enhance your skills in file handling and data processing. You have made substantial progress in mastering file manipulation in C#.