Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1, Lab 3

Streams and Directory Operations in C#

How a program moves bytes in and out of files, and how it walks the folders that hold them

Objectives

Explain what a stream is and the three kinds of stream types: backing stores, adapters, decorators
Release files correctly with IDisposable, Dispose() and the using statement
Open a FileStream with the right FileMode, FileAccess and FileShare, and predict Position and Length
Read and write text with StreamReader / StreamWriter and values with BinaryReader / BinaryWriter
Use the File shortcuts and the DeflateStream decorator
Create, list, measure, copy and search directory trees with Directory, DirectoryInfo and FileInfo

Part 1

What a Stream Is

Bytes flowing between a program and the outside world

A Stream Is a Sequence of Bytes

Stream: A sequence of bytes travelling from a source to a destination. A file opened for reading or writing is a stream.

An input stream is used to read; an output stream is used to write
The data can live in a file, on the network, or on the internet: the program sees the same byte flow
A stream can be readable, writable or both, and some are seekable: they keep a position you can move

Predict: How Big Is the File?

A new text file holds only A. Then it holds A, four spaces and z. How many bytes each time?

text

Size: 1 byte(s)
Size: 6 byte(s)
65 = 01000001 = 'A'
32 = 00100000 = ' '
32 = 00100000 = ' '
32 = 00100000 = ' '
32 = 00100000 = ' '
122 = 01111010 = 'z'

Output of the program, run on Windows

One character is stored as one byte (8 bits) here
A is the number 65, a space is 32, z is 122
The editor shows letters; the disk holds numbers

Three Kinds of Stream Types

External source

file, network

bytes

Backing store

FileStream

bytes

Decorator

DeflateStream

bytes

Adapter

StreamReader, BinaryWriter

text, int, bool

Your program

Backing store: talks to the external source directly and moves raw bytes
Decorator: transforms the bytes (for example compresses them) and is still a stream
Adapter: shows the bytes to the program in a useful shape, such as text lines or numbers

Part 2

Cleaning Up: IDisposable and using

Who closes the file?

Unmanaged Resources and the Dispose Pattern

An open file is an operating system handle the garbage collector does not track: its class implements IDisposable, and you call Dispose().

csharp

class LogFile : IDisposable
{
    private readonly FileStream fs;
    private bool disposed = false;
    public void Dispose()
    { Dispose(true); GC.SuppressFinalize(this); }
    protected virtual void Dispose(bool disposing)
    {
        if (disposed) return;
        if (disposing) fs.Dispose();
        disposed = true;
    }
    ~LogFile() { Dispose(false); }
}

Implement IDisposable
A public Dispose() for the users of the class
A protected virtual Dispose(bool) that does the work; the disposed flag makes it run once
GC.SuppressFinalize(this): cleanup is done, skip the finalizer
The finalizer is the safety net if someone forgets

Four Ways to Release a Resource

Way	Shape	Verdict
Call it yourself	`r.Dispose();` at the end	skipped if an exception is thrown first
try / finally	`finally { r?.Dispose(); }`	always runs; `?.` guards a failed constructor
using block	`using (var r = ...) { ... }`	disposed at the closing brace
using declaration	`using var r = ...;`	disposed at the end of the enclosing scope

Predict: When Does a using Declaration Dispose?

csharp

using LogFile log4 = new LogFile("log.txt");
log4.Write(67);
Console.WriteLine("end of Main");

text

LogFile: file opened
end of Main
LogFile: file closed

Part 3

FileStream: the Backing Store

Bytes, a position, and the rules for opening a file

FileMode: Missing File? Old Data?

new FileStream(path, FileMode, FileAccess, FileShare): the mode answers both questions.

Can create	File missing	File exists
`Create`	creates it	empties it (overwrites)
`CreateNew`	creates it	throws `IOException`
`OpenOrCreate`	creates it	opens it, Position `0`
`Append`	creates it	opens it, Position at the end (`Write` only)

Needs the file	File missing	File exists
`Open`	throws `FileNotFoundException`	opens it, Position `0`
`Truncate`	throws `FileNotFoundException`	opens it and cuts it to `0` bytes

Worked Example: HELLO Meets Each Mode (1)

test.txt holds HELLO. Open it with FileAccess.Write, write a then b, close. Predict the file.

FileMode	Right after opening	File after writing ab
`Append`	Position `5`, Length `5`	`HELLOab`
`Create`	Position `0`, Length `0`	`ab`
`CreateNew`	IOException	unchanged

Worked Example: HELLO Meets Each Mode (2)

Same file, same two bytes. Now Open, OpenOrCreate, Truncate.

FileMode	Right after opening	File after writing ab
`Open`	Position `0`, Length `5`	`abLLO`
`OpenOrCreate`	Position `0`, Length `5`	`abLLO`
`Truncate`	Position `0`, Length `0`	`ab`

FileAccess, Can Properties and Position

text

Read only : CanRead=True CanWrite=False CanSeek=True
Read write: CanRead=True CanWrite=True CanSeek=True

csharp

fs.WriteByte(65);
fs.WriteByte(66);

text

Position=0 Length=0
Position=1 Length=1
Position=2 Length=2
File now holds: AB

CanRead / CanWrite follow the FileAccess; CanSeek is true for a file
Position starts at 0, like the cursor at the start of a file
Each WriteByte writes one byte at Position and moves it forward by 1
Writing at the end makes Length grow

Predict: Which Lines Throw?

data.txt holds HELLO. Each case opens its own stream, then does one thing.

Opened with	Then
`Open`, `Write`	`fs.ReadByte()`
`Open`, `Read`	`fs.WriteByte(65)`
`Append`, `Read`	nothing
`Append`, `Write`	`fs.Seek(0, SeekOrigin.Begin)`

text

ReadByte on a Write-only stream:
  NotSupportedException
WriteByte on a Read-only stream:
  NotSupportedException
Append with FileAccess.Read:
  ArgumentException
Append, then Seek back to 0:
  IOException

Output on Windows, each line wrapped after its colon

FileShare: What Others May Do

None: nobody else may open the file
Read: others may open it for reading
Write: others may open it for writing
ReadWrite: others may read and write
Inheritable: a child process can inherit the handle

text

FileShare.Read: second reader opened, first byte = 72
FileShare.Read: a writer was refused (IOException)
FileShare.None: second reader was refused (IOException)

First stream holds the file; a second one tries to open it (Windows)

Reading Into a Buffer

Read may return fewer bytes than asked, so loop until nothing is left; it returns 0 at the end. The file holds C# streams: predict the bytes.

csharp

data = new byte[fs.Length];
int numBytesToRead = (int)fs.Length;
int numBytesRead = 0;
while (numBytesToRead > 0)
{
    int n = fs.Read(data, numBytesRead, numBytesToRead);
    if (n == 0) break;     // end of the file
    numBytesRead += n;
    numBytesToRead -= n;
}

text

Read 10 bytes:
67 35 32 115 116 114 101 97 109 115 
copy.txt holds: C# streams

Then fs.Write(data, 0, data.Length) into copy.txt

Seek and SeekOrigin

csharp

fs.Seek(offset, SeekOrigin.Begin);   // or Current, or End

p = b + o

p: the new Position, o: the offset you pass
b is 0 for Begin, the current Position for Current, the Length for End
The new Position must not be negative; it may be past the end

Worked Example: Seek Past the End

New empty file. fs.Seek(20, SeekOrigin.Begin); fs.WriteByte(65); then read every byte from 0. Predict the Length and the bytes.

text

Position=21 Length=21
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 65

Try It: Move the File Pointer

Part 4

Adapters, Shortcuts and a Decorator

Turn bytes into lines and values, or compress them

StreamWriter: When Does the Text Reach the File?

Write and WriteLine add text, Flush pushes the buffered text down to the file, Close flushes and closes. Predict each size.

csharp

var w = new StreamWriter(fs);  // fs: note.txt
w.Write("Hello");      // size?
w.Flush();             // size?
w.WriteLine(" OS");    // size?
w.Close();             // size?

text

After Write : file size = 0
After Flush : file size = 5
After WriteLine: file size = 5
After Close : file size = 10

Output on Windows

StreamReader: Predict Peek, Read, ReadLine

lines.txt holds Streams, and, Directories. Peek looks without consuming, Read consumes one character, ReadLine one line (null at the end).

csharp

Console.WriteLine("Peek: " + sr.Peek() + " = '" + (char)sr.Peek() + "'");
Console.WriteLine("Read: " + (char)sr.Read());
Console.WriteLine("Peek: " + (char)sr.Peek());
Console.WriteLine("ReadLine: " + sr.ReadLine());

text

Peek: 83 = 'S'
Read: S
Peek: t
ReadLine: treams

The ReadLine Loop

csharp

sr.BaseStream.Seek(0, SeekOrigin.Begin);
string str = sr.ReadLine();
while (str != null)
{
    Console.WriteLine(str);
    str = sr.ReadLine();
}

text

1: Streams
2: and
3: Directories
ReadLine returned null after line 3

text

Characters read: 25
File size: 25 bytes

Windows: 25 bytes = 21 letters + two end of line pairs

BinaryWriter and BinaryReader

Values are stored in binary form, not as text. Predict the file size: an int, a double, a bool, a double.

csharp

dataout = new BinaryWriter(
    new FileStream("data", FileMode.Create));
dataout.Write(20);            // int
dataout.Write(101.50);        // double
dataout.Write(true);          // bool
dataout.Write(12.2 * 15.5);   // double
dataout.Close();

4 + 8 + 1 + 8 = 21

text

File size: 21 bytes
First 4 bytes (the int 20): 20 0 0 0
Byte 12 (the bool true): 1

The int 20 is stored lowest byte first

The File Class: One Call Does It

Method	What it does
`File.WriteAllText` / `ReadAllText`	write / read a whole file as one string
`File.WriteAllLines` / `ReadAllLines`	write / read an array of lines
`File.WriteAllBytes` / `ReadAllBytes`	write / read an array of bytes
`File.Exists` / `File.Delete`	check for a file / delete it
`File.Move`	move or rename: there is no `Rename` method

DeflateStream: a Decorator That Compresses

The decorator wraps the FileStream and is itself a stream; CompressionMode.Decompress gives the bytes back. Predict the size on disk.

csharp

using (FileStream fs = File.Create("data.bin"))
using (DeflateStream ds = new DeflateStream(fs, CompressionMode.Compress))
    ds.Write(original, 0, original.Length);   // 1000 bytes: ABCABC...

text

Original bytes  : 1000
data.bin on disk: 15 bytes
Bytes after decompress: 1000 (first 65, last 65)

Output on Windows

Part 5

Directories

Create, list, measure, copy and search folders

Directory or DirectoryInfo?

	`Directory`	`DirectoryInfo`
Kind	static class	one object per folder
Call	`Directory.Exists(path)`	`new DirectoryInfo(path).Exists`
Gives	strings (paths)	`DirectoryInfo` and `FileInfo` objects

Create, move and delete: CreateDirectory, Move, Delete
List: GetDirectories, GetFiles, GetFileSystemEntries
Ask: GetCurrentDirectory, GetDirectoryRoot, GetLogicalDrives, GetCreationTime, GetLastWriteTime

Directory Basics on Windows

csharp

Console.WriteLine("Root: " + Directory.GetDirectoryRoot(curDir));
Console.WriteLine("Drives: " + string.Join(" ", Directory.GetLogicalDrives()));
File.WriteAllText("lab3/test/a.txt", "abc");
Directory.Delete("lab3/test");   // inside try / catch: predict!

text

Root: D:\
Drives: C:\ D:\
Delete(test) failed: IOException

Recorded on a build machine that works on drive D:. A lab PC usually prints Root: C:\

The Sample Tree

Built by MakeSampleTree() in every directory program. Sizes are real file lengths.

text

site
    about.txt       48 bytes
    work.txt        13 bytes
    images
        logo.bin   300 bytes
    wiki
        home.txt    19 bytes
        week1.txt   25 bytes
        old
            week0.txt  13 bytes

about.txt holds "Streams move bytes between a program and a file."
week1.txt holds "Week 1: what is a stream?"
Windows returns names in alphabetical order

Predict: What Does Each Search Return?

csharp

Directory.GetFileSystemEntries("site", "w*");
Directory.GetFiles("site", "w*", SearchOption.AllDirectories);

text

GetFileSystemEntries(site, w*):
   site\wiki
   site\work.txt
GetFiles(site, w*, AllDirectories):
   site\work.txt
   site\wiki\week1.txt
   site\wiki\old\week0.txt

FileInfo: the Size of a Folder

FileInfo.Length is one file's size in bytes. Predict the size of the sample tree, then of its top folder alone (TopDirectoryOnly).

Name, Extension, FullName, Directory, and Length (in bytes)
CreationTime, LastAccessTime, LastWriteTime
Methods: Create, AppendText, Delete, Open, OpenRead, CopyTo

csharp

foreach (FileInfo fi in dirInfo.GetFiles("*", SearchOption.AllDirectories))
    size += fi.Length;

48 + 13 + 300 + 19 + 25 + 13 = 418

text

The directory size: 418 bytes
Top level files only: 61 bytes

Recursive Copy: DirectoryCopy

DirectoryCopy("site", "site-2", true) prints each folder it creates and each file it copies. Predict the order.

csharp

var dir = new DirectoryInfo(source);
DirectoryInfo[] dirs = dir.GetDirectories();
if (!Directory.Exists(dest))
    Directory.CreateDirectory(dest);
foreach (FileInfo file in dir.GetFiles())
    file.CopyTo(Path.Combine(dest, file.Name), false);
if (copySubDirs)
    foreach (DirectoryInfo subdir in dirs)
        DirectoryCopy(subdir.FullName,
            Path.Combine(dest, subdir.Name), copySubDirs);

The body of DirectoryCopy (full method in the lesson page)

text

create site-2
  copy site-2\about.txt
  copy site-2\work.txt
create site-2\images
  copy site-2\images\logo.bin
create site-2\wiki
  copy site-2\wiki\home.txt
  copy site-2\wiki\week1.txt
create site-2\wiki\old
  copy site-2\wiki\old\week0.txt
Copying finished
Files in site-2: 6

Output on Windows

Try It: Watch the Recursion

Part 6

Practice

About 30 minutes: predict first, then run it

About 6 minutes

Practice 1: Trace the Pointer

csharp

File.WriteAllText("data.txt", "STREAM");
using var fs = new FileStream("data.txt", FileMode.Open, FileAccess.ReadWrite);
fs.ReadByte();  fs.ReadByte();
fs.Seek(2, SeekOrigin.Current);
fs.WriteByte(33);
fs.Seek(-1, SeekOrigin.End);
fs.ReadByte();  fs.ReadByte();
fs.Seek(8, SeekOrigin.Begin);
fs.WriteByte(90);

Practice 1: Answer

text

1) ReadByte() = 83, Position = 1
2) ReadByte() = 84, Position = 2
3) Seek(2, Current): Position = 4
4) WriteByte(33): Position = 5, Length = 6
5) Seek(-1, End): Position = 5
6) ReadByte() = 77, Position = 6
7) ReadByte() = -1, Position = 6
8) Seek(8, Begin), WriteByte(90): Position = 9, Length = 9
Bytes: 83 84 82 69 33 77 0 0 90

Output on Windows

About 5 minutes

Practice 2: Choose and Predict the Mode

(a) A log file must gain one line per run and keep the old lines. Which FileMode and FileAccess?
(b) FileMode.CreateNew is used twice in a row on new.txt. What happens each time?
(c) hello.txt holds HELLO. Open with Open, Write, then WriteByte((byte)'J'). The file?
(d) Then FileMode.Truncate with FileAccess.Read. What happens, and what does the file hold?

Practice 2: Answer

Case	Answer
(a)	`Append` with `Write`: 3 runs give 3 lines
(b)	created, then IOException: the file exists
(c)	`JELLO`: `Open` keeps the data, `J` overwrites `H`
(d)	ArgumentException: `Truncate` needs write access; still `JELLO`

About 4 minutes

Practice 3: Size of a Binary Record

csharp

bw.Write(7);
bw.Write(true);
bw.Write(3.5);
bw.Write(false);
bw.Write(1000);

Practice 3: Answer

4 + 1 + 8 + 1 + 4 = 18

text

Size: 18 bytes
7 True 3.5 False 1000
Last 4 bytes: 232 3 0 0

Output on Windows

About 5 minutes

Practice 4: Count the Lines

Write Windows, Linux, macOS, FreeBSD, Android to os.txt with a StreamWriter, one per line
Read it back with StreamReader.ReadLine until it returns null
Print the number of lines and the longest line with its length
Predict: which line is the longest, and how big is the file on Windows?

Practice 4: Answer

csharp

string line = sr.ReadLine();
while (line != null)
{
    count++;
    if (line.Length > longest.Length)
        longest = line;
    line = sr.ReadLine();
}

text

Lines: 5
Longest: Windows (7 characters)
File size: 41 bytes

Output on Windows

31 + 5 × 2 = 41

About 6 minutes

Practice 5: Print the Tree

Write a recursive PrintTree(DirectoryInfo dir, string indent)
Print the folder name and /, then its files with their sizes, then call itself for each subfolder with a deeper indent
It returns the total size of the files below the folder
Run it on site: print the total, then the size of site/wiki alone

Practice 5: Answer

csharp

static long PrintTree(DirectoryInfo dir, string indent)
{
    long total = 0;
    Console.WriteLine(indent + dir.Name + "/");
    foreach (FileInfo f in dir.GetFiles())
    {
        Console.WriteLine(indent + "    " + f.Name
            + " (" + f.Length + ")");
        total += f.Length;
    }
    foreach (DirectoryInfo sub in dir.GetDirectories())
        total += PrintTree(sub, indent + "    ");
    return total;
}

text

site/
    about.txt (48)
    work.txt (13)
    images/
        logo.bin (300)
    wiki/
        home.txt (19)
        week1.txt (25)
        old/
            week0.txt (13)
Total: 418 bytes
wiki: 57 bytes

Output on Windows

Practice 5: Answer, the Two Totals

About 5 minutes

Practice 6: Fix the Search

DirSearch("site") from the source, searching for stream

csharp

foreach (var directory in Directory.GetDirectories(sDir))
{
    foreach (var filename in Directory.GetFiles(directory))
    {
        // read it, lower-case it,
        // add it if it contains "stream"
    }
    DirSearch(directory);
}

Predict: which files does DirSearch report?
Write FileSearch(string sDir): search the files of sDir first, then call itself for each subfolder
Which files must FileSearch report?

Practice 6: Answer

csharp

foreach (var filename in Directory.GetFiles(sDir))
    using (var sr = new StreamReader(filename))
        if (sr.ReadToEnd().ToLower().Contains(SearchText))
            FilesFound.Add(filename);
foreach (var directory in Directory.GetDirectories(sDir))
    FileSearch(directory);

text

DirSearch: files containing the word stream
   site\wiki\week1.txt
FileSearch: files containing the word stream
   site\about.txt
   site\wiki\week1.txt

Output on Windows

Key Takeaways

A stream is a flow of bytes; backing stores, decorators and adapters each do one job
Anything IDisposable gets disposed: prefer using
FileMode answers "missing?" and "old data?"; FileAccess limits what the stream may do; Open overwrites in place
Seeking past the end and writing fills the gap with 0 bytes
Writers buffer: nothing is on disk before Flush or Close
Recursion walks a tree: handle this folder's files, then call yourself for each subfolder

Open this lesson

Mahmoud AbasStreams and Directory Operations in C#