Edit

Share via

Compose streams

  • 08/07/2024

A backing store is a storage medium, such as a disk or memory. Each type of backing store implements its own stream as an implementation of the Stream class.

Each stream type reads and writes bytes from and to its given backing store. Streams that connect to backing stores are called base streams. Base streams have constructors with the parameters necessary to connect the stream to the backing store. For example, FileStream has constructors that specify an access mode parameter, which determines if the file is read from, written to, or both.

The design of the System.IO classes provides simplified stream composition. You can attach base streams to one or more pass-through streams that provide the functionality you want. You can attach a reader or writer to the end of the chain, so the preferred types can be read or written easily.

Prerequisites

These examples use a plain-text file named data.txt. This file should contain some text.

Example: Encrypt and decrypt stream data

The following example reads data from a file, encrypts it, and then writes the encrypted data to another file. Stream composition is used to transform the data using a basic shifting cipher. Each byte that passes through the stream has its value changed by 80.

Warning

The encryption used in this example is basic and unsecure. It's not meant to actually encrypt data for use, but is provided to demonstrate altering data through stream composition.

Read the source data for encryption

The following code reads the text from one file, transforms it, then writes it to another file.

Tip

Before reviewing this code, know that the CipherStream is a user-defined type. The code for this class is provided in the CipherStream class section.

C# 
void WriteShiftedFile()
{
    // Create the base streams for the input and output files
    using FileStream inputBaseStream = File.OpenRead("data.txt");
    using CipherStream encryptStream = CipherStream.CreateForRead(inputBaseStream);
    using FileStream outputBaseStream = File.Open("shifted.txt", FileMode.Create, FileAccess.Write);

    int intValue;

    // Read byte from inputBaseStream through the encryptStream (normal bytes into shifted bytes)
    while ((intValue = encryptStream.ReadByte()) != -1)
    {
        outputBaseStream.WriteByte((byte)intValue);
    }

    // Process is:
    //  (inputBaseStream -> encryptStream) -> outputBaseStream
}

Consider the following aspects about the previous code:

  • There are two FileStream objects:
    • The first FileStream (inputBaseStream variable) object reads the contents of the data.txt file. This is the input data stream.
    • The second FileStream (outputBaseStream variable) object writes incoming data to the shifted.txt file. This is the output data stream.
  • The CipherStream (encryptStream variable) object wraps the inputBaseStream, making inputBaseStream the base stream for encryptStream.

The input stream could be read from directly, writing the data to the output stream, but that wouldn't transform the data. Instead, the encryptStream input stream wrapper is used to read the data. As the data is read from encryptStream, it pulls from the inputBaseStream base stream, transforms it, and returns it. The returned data is written to outputBaseStream, which writes the data to the shifted.txt file.

Read the transformed data for decryption

This code reverses the encryption performed by the previous code:

C# 
void ReadShiftedFile()
{
    int intValue;

    // Create the base streams for the input and output files
    using FileStream inputBaseStream = File.OpenRead("shifted.txt");
    using FileStream outputBaseStream = File.Open("unshifted.txt", FileMode.Create, FileAccess.Write);
    using CipherStream unencryptStream = CipherStream.CreateForWrite(outputBaseStream);

    // Read byte from inputBaseStream through the encryptStream (shifted bytes into normal bytes)
    while ((intValue = inputBaseStream.ReadByte()) != -1)
    {
        unencryptStream.WriteByte((byte)intValue);
    }

    // Process is:
    //  inputBaseStream -> (encryptStream -> outputBaseStream)
}

Consider the following aspects about the previous code:

  • There are two FileStream objects:
    • The first FileStream (inputBaseStream variable) object reads the contents of the shifted.txt file. This is the input data stream.
    • The second FileStream (outputBaseStream variable) object writes incoming data to the unshifted.txt file. This is the output data stream.
  • The CipherStream (unencryptStream variable) object wraps the outputBaseStream, making outputBaseStream the base stream for unencryptStream.

Here, the code is slightly different from the previous example. Instead of wrapping the input stream, unencryptStream wraps the output stream. As the data is read from inputBaseStream input stream, it's sent to the unencryptStream output stream wrapper. When unencryptStream receives data, it transforms it and then writes the data to the outputBaseStream base stream. The outputBaseStream output stream writes the data to the unshifted.txt file.

Validate the transformed data

The two previous examples performed two operations on the data. First, the contents of the data.txt file was encrypted and saved to the shifted.txt file. And second, the encrypted contents of the shifted.txt file were decrypted and saved to the unshifted.txt file. Therefore, the data.txt file and unshifted.txt file should be exactly the same. The following code compares those files for equality:

C# 
bool IsShiftedFileValid()
{
    // Read the shifted file
    string originalText = File.ReadAllText("data.txt");

    // Read the shifted file
    string shiftedText = File.ReadAllText("unshifted.txt");

    // Check if the decrypted file is valid
    return shiftedText == originalText;
}

The following code runs this entire encrypt-decrypt process:

C# 
// Read the contents of data.txt, encrypt it, and write it to shifted.txt
WriteShiftedFile();

// Read the contents of shifted.txt, decrypt it, and write it to unshifted.txt
ReadShiftedFile();

// Check if the decrypted file is valid
Console.WriteLine(IsShiftedFileValid()
                    ? "Decrypted file is valid"     // True
                    : "Decrypted file is invalid"   // False
                 );

// Output:
//   Decrypted file is valid

CipherStream class

The following snippet provides the CipherStream class, which uses a basic shifting cipher to encrypt and decrypt bytes. This class inherits from Stream and supports either reading or writing data.

Warning

The encryption used in this example is basic and unsecure. It's not meant to actually encrypt data for use, but is provided to demonstrate altering data through stream composition.

C# 
using System.IO;

public class CipherStream : Stream
{
    // WARNING: This is a simple encoding algorithm and should not be used in production code

    const byte ENCODING_OFFSET = 80;

    private bool _readable;
    private bool _writable;

    private Stream _wrappedBaseStream;

    public override bool CanRead => _readable;
    public override bool CanSeek => false;
    public override bool CanWrite => _writable;
    public override long Length => _wrappedBaseStream.Length;
    public override long Position
    {
        get => _wrappedBaseStream.Position;
        set => _wrappedBaseStream.Position = value;
    }

    public static CipherStream CreateForRead(Stream baseStream)
    {
        return new CipherStream(baseStream)
        {
            _readable = true,
            _writable = false
        };
    }

    public static CipherStream CreateForWrite(Stream baseStream)
    {
        return new CipherStream(baseStream)
        {
            _readable = false,
            _writable = true
        };
    }

    private CipherStream(Stream baseStream) =>
        _wrappedBaseStream = baseStream;

    public override int Read(byte[] buffer, int offset, int count)
    {
        if (!_readable) throw new NotSupportedException();
        if (count == 0) return 0;

        int returnCounter = 0;

        for (int i = 0; i < count; i++)
        {
            int value = _wrappedBaseStream.ReadByte();

            if (value == -1)
                return returnCounter;

            value += ENCODING_OFFSET;
            if (value > byte.MaxValue)
                value -= byte.MaxValue;

            buffer[i + offset] = Convert.ToByte(value);
            returnCounter++;
        }

        return returnCounter;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        if (!_writable) throw new NotSupportedException();

        byte[] newBuffer = new byte[count];
        buffer.CopyTo(newBuffer, offset);

        for (int i = 0; i < count; i++)
        {
            int value = newBuffer[i];

            value -= ENCODING_OFFSET;

            if (value < 0)
                value = byte.MaxValue - value;

            newBuffer[i] = Convert.ToByte(value);
        }

        _wrappedBaseStream.Write(newBuffer, 0, count);
    }

    public override void Flush() => _wrappedBaseStream.Flush();
    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
    public override void SetLength(long value) => throw new NotSupportedException();
}

See also

Additional resources