Streams

• File is a collection of data stored in a disk with a specific name and a path.
• When a file is opened for reading or writing, it becomes a stream.
• The Stream class and its derived classes provide a generic view of these different types of input/output and isolate the programmer from the specific details of the OS.
  • Stream is the abstract base class of all streams, which is an abstraction of a sequence of bytes.
• Streams involve three fundamental operations:

1. Read, which is the transfer of data from a stream into a data structure, such as an array of bytes.
2. Write, which is the transfer of data from into a stream.
3. Streams can support seeking.
   • Some streams have the concept of a current position that you can query.
   • Files mostly support seeking (depending on the file type).

var originalInstance = new MyObject();
IFormatter formatter = new BinaryFormatter();

// Serialization
byte[] bytes;
using (var writeStream = new MemoryStream())
{
    formatter.Serialize(writeStream, originalInstance);
    bytes = writeStream.ToArray();
}

// Deserialization
using (var readStream = new MemoryStream(bytes))
{
    var deserializedInstance = (MyObject) formatter.Deserialize(readStream);
}

Encoding and Decoding

• The process of converting characters into bytes (and the other way around) is called encoding and decoding.
• A char is equivalent to a single Unicode character taking 2 bytes in memory. A string is simply a sequence of chars.
• System.Text.Encoding is the class that helps you convert between bytes and strings.
• UTF-8 is one that suffices for general purpose use. It can represent all Unicode characters and it is used as the default encoding in a lot of the .NET Framework classes.

FileStream Class

• The FileStream class in the System.IO namespace helps in reading from, writing to and closing files.
• You need to create a FileStream object to create a new file or open an existing file.
• When writing to a FileStream, you can use the synchronous method Write, which expects a byte array.
  • A simple File object does not store text directly. As already mentioned, a Stream works with bytes, so you need to convert your text into bytes.

const string filePath = "MyTest.txt";
using (var fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
    // Write into the file stream.
    var bytesToWrite = Encoding.UTF8.GetBytes("Test String...");
    fileStream.Write(bytesToWrite, 0, bytesToWrite.Length);
}

using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
    // Read the written data from the file stream.
    var bytesBuffer = new byte[fileStream.Length];
    fileStream.Seek(0, SeekOrigin.Begin);
    var bytesToRead = bytesBuffer.Length;
    var bytesRead = 0;
    while (bytesToRead > 0)
    {
        var resultedBytes = fileStream.Read(bytesBuffer, bytesRead, bytesToRead);
        if (resultedBytes == 0) // No bytes remained to read.
            bytesToRead = 0;
        else
        {
            bytesRead += resultedBytes;
            bytesToRead -= resultedBytes;
        }
    }
    var outputString = Encoding.UTF8.GetString(bytesBuffer);
}

File Class Utilities

• File class supports a CreateText() method that creates a file with an UTF-8 encoding for you.
• This method returns a StreamWriter, a class that inherits from TextWriter and enables you to directly write characters to a Stream with a particular encoding.
• If you know that you are parsing a text file, you can also use a StreamReader to read a text file. It uses a default encoding and returns the bytes to as a string.

const string filePath = "MyTest.txt";

using (FileStream fileStream = File.OpenRead(filePath))
{
    var bytesBuffer = new byte[fileStream.Length];
    for (var i = 0; i < fileStream.Length; i++)
        bytesBuffer[i] = (byte)fileStream.ReadByte();
}

using (StreamReader streamReader = File.OpenText(filePath))
{
    var fileContent = streamReader.ReadToEnd();
}

// You can use this approach to read the file content line by line.
using (StreamReader streamReader = File.OpenText(filePath))
{
    while (!streamReader.EndOfStream)
    {
        var lineContent = streamReader.ReadLine();
    }
}

using (StreamWriter streamWriter = File.CreateText(filePath))
{
    streamWriter.WriteLine("Line 1");
    streamWriter.Write("Line 2");
}

Using Different Types of Streams Together

• Because of the way Streams are designed, you can couple multiple Stream objects together to perform a more complex operation.
• E.g when compressing some data, you can use a GZipStream, which takes another Stream object in its constructor and use it as the input or output for the compression.