التدفقات وعمليات المجلدات بلغة C#

using System;
using System.IO;

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        File.WriteAllText("sample.txt", "A");
        Console.WriteLine("Size: " + new FileInfo("sample.txt").Length + " byte(s)");
 
        File.WriteAllText("sample.txt", "A    z");
        Console.WriteLine("Size: " + new FileInfo("sample.txt").Length + " byte(s)");
 
        byte[] data = File.ReadAllBytes("sample.txt");
        foreach (byte b in data)
        {
            Console.WriteLine(b + " = " + Convert.ToString(b, 2).PadLeft(8, '0') + " = '" + (char)b + "'");
        }
    }
}

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

using System;
using System.IO;
 
class LogFile : IDisposable
{
    private readonly FileStream fs;      // holds an operating system file handle
    private bool disposed = false;
 
    public LogFile(string path)
    {
        fs = new FileStream(path, FileMode.Create, FileAccess.Write);
        Console.WriteLine("LogFile: file opened");
    }
 
    public void Write(byte b)
    {
        fs.WriteByte(b);
    }
 
    public void Dispose()                // step 2: the public method clients call
    {
        Dispose(true);
        GC.SuppressFinalize(this);       // cleanup done, the finalizer is not needed
    }
 
    protected virtual void Dispose(bool disposing)   // step 3
    {
        if (disposed)
        {
            Console.WriteLine("LogFile: already disposed, nothing to do");
            return;
        }
        if (disposing)
        {
            fs.Dispose();                // release the managed object we own
            Console.WriteLine("LogFile: file closed");
        }
        disposed = true;
    }
 
    ~LogFile()                           // safety net: the garbage collector calls it
    {
        Dispose(false);
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("1) using block");
        using (LogFile log = new LogFile("log.txt"))
        {
            log.Write(65);
            Console.WriteLine("inside the block");
        }
        Console.WriteLine("after the block");
 
        Console.WriteLine("2) try / finally");
        LogFile log2 = null;
        try
        {
            log2 = new LogFile("log.txt");
            log2.Write(66);
        }
        finally
        {
            log2?.Dispose();
        }
 
        Console.WriteLine("3) Dispose called twice");
        LogFile log3 = new LogFile("log.txt");
        log3.Dispose();
        log3.Dispose();
 
        Console.WriteLine("4) using declaration");
        using LogFile log4 = new LogFile("log.txt");
        log4.Write(67);
        Console.WriteLine("end of Main");
    }
}

1) using block
LogFile: file opened
inside the block
LogFile: file closed
after the block
2) try / finally
LogFile: file opened
LogFile: file closed
3) Dispose called twice
LogFile: file opened
LogFile: file closed
LogFile: already disposed, nothing to do
4) using declaration
LogFile: file opened
end of Main
LogFile: file closed

using (LogFile log = new LogFile("log.txt"))
{
    log.Write(65);
}

LogFile log = new LogFile("log.txt");
try
{
    log.Write(65);
}
finally
{
    log?.Dispose();
}

FileStream fs = new FileStream("data.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

using System;
using System.IO;
 
class Program
{
    static void Try(FileMode mode, bool exists)
    {
        string path = "test.txt";
        if (File.Exists(path)) File.Delete(path);
        if (exists) File.WriteAllText(path, "HELLO");
 
        string label = mode + (exists ? " (file has HELLO)" : " (no file)");
        try
        {
            using (var fs = new FileStream(path, mode, FileAccess.Write))
            {
                long pos = fs.Position, len = fs.Length;
                fs.WriteByte((byte)'a');
                fs.WriteByte((byte)'b');
                fs.Close();
                Console.WriteLine("{0,-32} Position={1} Length={2} -> after writing ab: {3}",
                    label, pos, len, File.ReadAllText(path));
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("{0,-32} {1}", label, ex.GetType().Name);
        }
    }
 
    static void Main(string[] args)
    {
        FileMode[] modes = { FileMode.Append, FileMode.Create, FileMode.CreateNew,
                             FileMode.Open, FileMode.OpenOrCreate, FileMode.Truncate };
        foreach (FileMode m in modes) Try(m, false);
        Console.WriteLine();
        foreach (FileMode m in modes) Try(m, true);
    }
}

Append (no file)                 Position=0 Length=0 -> after writing ab: ab
Create (no file)                 Position=0 Length=0 -> after writing ab: ab
CreateNew (no file)              Position=0 Length=0 -> after writing ab: ab
Open (no file)                   FileNotFoundException
OpenOrCreate (no file)           Position=0 Length=0 -> after writing ab: ab
Truncate (no file)               FileNotFoundException
 
Append (file has HELLO)          Position=5 Length=5 -> after writing ab: HELLOab
Create (file has HELLO)          Position=0 Length=0 -> after writing ab: ab
CreateNew (file has HELLO)       IOException
Open (file has HELLO)            Position=0 Length=5 -> after writing ab: abLLO
OpenOrCreate (file has HELLO)    Position=0 Length=5 -> after writing ab: abLLO
Truncate (file has HELLO)        Position=0 Length=0 -> after writing ab: ab

using System;
using System.IO;
 
class Program
{
    static void Run(string title, Action action)
    {
        try
        {
            action();
            Console.WriteLine(title + ": OK");
        }
        catch (Exception ex)
        {
            Console.WriteLine(title + ": " + ex.GetType().Name);
        }
    }
 
    static void Main(string[] args)
    {
        File.WriteAllText("data.txt", "HELLO");
 
        Run("ReadByte on a Write-only stream", () =>
        {
            using var fs = new FileStream("data.txt", FileMode.Open, FileAccess.Write);
            fs.ReadByte();
        });
        Run("WriteByte on a Read-only stream", () =>
        {
            using var fs = new FileStream("data.txt", FileMode.Open, FileAccess.Read);
            fs.WriteByte(65);
        });
        Run("Append with FileAccess.Read", () =>
        {
            using var fs = new FileStream("data.txt", FileMode.Append, FileAccess.Read);
        });
        Run("Append, then Seek back to 0", () =>
        {
            using var fs = new FileStream("data.txt", FileMode.Append, FileAccess.Write);
            fs.Seek(0, SeekOrigin.Begin);
        });
        Console.WriteLine("File still holds: " + File.ReadAllText("data.txt"));
    }
}

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
File still holds: HELLO

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        File.WriteAllText("shared.txt", "HELLO");
 
        using (var first = new FileStream("shared.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            using (var second = new FileStream("shared.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                Console.WriteLine("FileShare.Read: second reader opened, first byte = " + second.ReadByte());
            }
            try
            {
                using var writer = new FileStream("shared.txt", FileMode.Open, FileAccess.Write, FileShare.Read);
                Console.WriteLine("FileShare.Read: a writer opened");
            }
            catch (IOException ex)
            {
                Console.WriteLine("FileShare.Read: a writer was refused (" + ex.GetType().Name + ")");
            }
        }
 
        using (var locked = new FileStream("shared.txt", FileMode.Open, FileAccess.Read, FileShare.None))
        {
            try
            {
                using var second = new FileStream("shared.txt", FileMode.Open, FileAccess.Read, FileShare.Read);
                Console.WriteLine("FileShare.None: second reader opened");
            }
            catch (IOException ex)
            {
                Console.WriteLine("FileShare.None: second reader was refused (" + ex.GetType().Name + ")");
            }
        }
    }
}

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

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        string path = "sample.txt";
        File.WriteAllText(path, "");     // start with an empty file
 
        using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            Console.WriteLine("Read only : CanRead={0} CanWrite={1} CanSeek={2}",
                fs.CanRead, fs.CanWrite, fs.CanSeek);
        }
 
        using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite))
        {
            Console.WriteLine("Read write: CanRead={0} CanWrite={1} CanSeek={2}",
                fs.CanRead, fs.CanWrite, fs.CanSeek);
            Console.WriteLine("Position={0} Length={1}", fs.Position, fs.Length);
            fs.WriteByte(65);
            Console.WriteLine("Position={0} Length={1}", fs.Position, fs.Length);
            fs.WriteByte(66);
            Console.WriteLine("Position={0} Length={1}", fs.Position, fs.Length);
        }
        Console.WriteLine("File now holds: " + File.ReadAllText(path));
    }
}

Read only : CanRead=True CanWrite=False CanSeek=True
Read write: CanRead=True CanWrite=True CanSeek=True
Position=0 Length=0
Position=1 Length=1
Position=2 Length=2
File now holds: AB

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        using (var fs = new FileStream("letters.txt", FileMode.Create, FileAccess.Write))
        {
            for (int i = 65; i < 123; i++)
            {
                fs.WriteByte((byte)i);
            }
            Console.WriteLine("Bytes written: " + fs.Length);
        }
        Console.WriteLine(File.ReadAllText("letters.txt"));
    }
}

Bytes written: 58
ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        File.WriteAllText("sample.txt", "C# streams");
        byte[] data;
 
        using (var fs = new FileStream("sample.txt", FileMode.Open, FileAccess.Read))
        {
            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;
            }
            Console.WriteLine("Read " + numBytesRead + " bytes:");
            foreach (byte b in data) Console.Write(b + " ");
            Console.WriteLine();
        }
 
        using (var fsw = new FileStream("copy.txt", FileMode.OpenOrCreate, FileAccess.Write))
        {
            fsw.Write(data, 0, data.Length);
        }
        Console.WriteLine("copy.txt holds: " + File.ReadAllText("copy.txt"));
    }
}

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

p = b + o

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        using (var fs = new FileStream("gap.txt", FileMode.Create, FileAccess.ReadWrite))
        {
            fs.Seek(20, SeekOrigin.Begin);
            fs.WriteByte(65);
            Console.WriteLine("Position={0} Length={1}", fs.Position, fs.Length);
 
            fs.Position = 0;
            for (int i = 0; i < fs.Length; i++)
            {
                Console.Write(fs.ReadByte() + " ");
            }
            Console.WriteLine();
 
            fs.Seek(-3, SeekOrigin.End);
            Console.WriteLine("Seek(-3, End) -> Position=" + fs.Position);
            fs.Seek(1, SeekOrigin.Current);
            Console.WriteLine("Seek(1, Current) -> Position=" + fs.Position);
        }
    }
}

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 
Seek(-3, End) -> Position=18
Seek(1, Current) -> Position=19

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        var fs = new FileStream("note.txt", FileMode.Create, FileAccess.Write);
        var w = new StreamWriter(fs);
 
        w.Write("Hello");
        Console.WriteLine("After Write : file size = " + new FileInfo("note.txt").Length);
 
        w.Flush();
        Console.WriteLine("After Flush : file size = " + new FileInfo("note.txt").Length);
 
        w.WriteLine(" OS");
        Console.WriteLine("After WriteLine: file size = " + new FileInfo("note.txt").Length);
 
        w.Close();                       // flushes, then closes the stream too
        Console.WriteLine("After Close : file size = " + new FileInfo("note.txt").Length);
    }
}

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

using System;
using System.IO;
 
class Program
{
    public void WriteData()
    {
        FileStream fs = new FileStream("data.txt", FileMode.Append, FileAccess.Write);
        StreamWriter w = new StreamWriter(fs);
        Console.WriteLine("Enter the string");
        string str = Console.ReadLine();
        w.WriteLine(str);
        w.Flush();
        fs.Close();
    }
 
    static void Main(string[] args)
    {
        if (File.Exists("data.txt")) File.Delete("data.txt");
        Program p = new Program();
        p.WriteData();
        p.WriteData();
        Console.WriteLine("data.txt now holds:");
        Console.Write(File.ReadAllText("data.txt"));
    }
}

Enter the string
Enter the string
data.txt now holds:
first run
second run

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        using (var sw = new StreamWriter("lines.txt"))
        {
            sw.WriteLine("Streams");
            sw.WriteLine("and");
            sw.Write("Directories");
        }
 
        using (var sr = new StreamReader("lines.txt"))
        {
            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());
        }
 
        Console.WriteLine("-- ReadLine loop --");
        FileStream fs = new FileStream("lines.txt", FileMode.Open, FileAccess.Read);
        StreamReader reader = new StreamReader(fs);
        reader.BaseStream.Seek(0, SeekOrigin.Begin);
        string str = reader.ReadLine();
        int count = 0;
        while (str != null)
        {
            count++;
            Console.WriteLine("{0}: {1}", count, str);
            str = reader.ReadLine();
        }
        Console.WriteLine("ReadLine returned null after line " + count);
        reader.Close();
        fs.Close();
 
        Console.WriteLine("-- Peek / Read loop --");
        using (var sr = new StreamReader("lines.txt"))
        {
            int chars = 0;
            while (sr.Peek() >= 0)
            {
                char c = (char)sr.Read();
                chars++;
            }
            Console.WriteLine("Characters read: " + chars);
        }
        Console.WriteLine("File size: " + new FileInfo("lines.txt").Length + " bytes");
    }
}

Peek: 83 = 'S'
Read: S
Peek: t
ReadLine: treams
-- ReadLine loop --
1: Streams
2: and
3: Directories
ReadLine returned null after line 3
-- Peek / Read loop --
Characters read: 25
File size: 25 bytes

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        BinaryReader datain;
        BinaryWriter dataout;
 
        int i = 20;
        double j = 101.50;
        bool b = true;
 
        dataout = new BinaryWriter(new FileStream("data", FileMode.Create));
        Console.WriteLine("Writing " + i);
        dataout.Write(i);
        Console.WriteLine("Writing " + j);
        dataout.Write(j);
        Console.WriteLine("Writing " + b);
        dataout.Write(b);
        Console.WriteLine("Writing " + 12.2 * 15.5);
        dataout.Write(12.2 * 15.5);
        dataout.Close();
 
        Console.WriteLine("File size: " + new FileInfo("data").Length + " bytes");
 
        datain = new BinaryReader(new FileStream("data", FileMode.Open));
        i = datain.ReadInt32();
        Console.WriteLine("Reading " + i);
        j = datain.ReadDouble();
        Console.WriteLine("Reading " + j);
        b = datain.ReadBoolean();
        Console.WriteLine("Reading " + b);
        j = datain.ReadDouble();
        Console.WriteLine("Reading " + j);
        datain.Close();
 
        byte[] raw = File.ReadAllBytes("data");
        Console.WriteLine("First 4 bytes (the int 20): {0} {1} {2} {3}", raw[0], raw[1], raw[2], raw[3]);
        Console.WriteLine("Byte 12 (the bool true): " + raw[12]);
    }
}

Writing 20
Writing 101.5
Writing True
Writing 189.1
File size: 21 bytes
Reading 20
Reading 101.5
Reading True
Reading 189.1
First 4 bytes (the int 20): 20 0 0 0
Byte 12 (the bool true): 1

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        string[] lines = { "Linux", "Windows", "macOS" };
        File.WriteAllLines("os.txt", lines);
        string[] back = File.ReadAllLines("os.txt");
        Console.WriteLine("ReadAllLines returned " + back.Length + " lines, the second is " + back[1]);
 
        File.WriteAllText("test.txt", "Streams are sequences of bytes");
        Console.WriteLine("ReadAllText: " + File.ReadAllText("test.txt"));
 
        File.WriteAllBytes("raw.bin", new byte[] { 72, 105 });
        Console.WriteLine("WriteAllBytes wrote: " + File.ReadAllText("raw.bin"));
 
        if (File.Exists("renamed.txt")) File.Delete("renamed.txt");
        File.Move("test.txt", "renamed.txt");
        Console.WriteLine("test.txt exists: " + File.Exists("test.txt"));
        Console.WriteLine("renamed.txt exists: " + File.Exists("renamed.txt"));
 
        File.Delete("renamed.txt");
        if (File.Exists("renamed.txt") == false)
            Console.WriteLine("File deleted...");
    }
}

ReadAllLines returned 3 lines, the second is Windows
ReadAllText: Streams are sequences of bytes
WriteAllBytes wrote: Hi
test.txt exists: False
renamed.txt exists: True
File deleted...

using System;
using System.IO;
using System.IO.Compression;
 
class Program
{
    static void Main(string[] args)
    {
        byte[] original = new byte[1000];
        for (int i = 0; i < original.Length; i++)
            original[i] = (byte)(65 + i % 3);            // ABCABCABC...
 
        using (FileStream fs = File.Create("data.bin"))
        using (DeflateStream ds = new DeflateStream(fs, CompressionMode.Compress))
        {
            ds.Write(original, 0, original.Length);
        }
        Console.WriteLine("Original bytes  : " + original.Length);
        Console.WriteLine("data.bin on disk: " + new FileInfo("data.bin").Length + " bytes");
 
        int count = 0, first = -1, last = -1;
        using (FileStream fs = File.OpenRead("data.bin"))
        using (DeflateStream ds = new DeflateStream(fs, CompressionMode.Decompress))
        {
            int b;
            while ((b = ds.ReadByte()) != -1)
            {
                if (first == -1) first = b;
                last = b;
                count++;
            }
        }
        Console.WriteLine("Bytes after decompress: " + count + " (first " + first + ", last " + last + ")");
    }
}

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

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        if (Directory.Exists("lab3")) Directory.Delete("lab3", true);
 
        DirectoryInfo di = Directory.CreateDirectory("lab3/test");
        Console.WriteLine($"Name: {di.Name}, Parent: {di.Parent.Name}");
        Console.WriteLine("Exists: " + Directory.Exists("lab3/test"));
 
        var curDir = Directory.GetCurrentDirectory();
        Console.WriteLine("Current directory: " + curDir);
        Console.WriteLine("Root: " + Directory.GetDirectoryRoot(curDir));
        Console.WriteLine("Drives: " + string.Join(" ", Directory.GetLogicalDrives()));
 
        File.WriteAllText("lab3/test/a.txt", "abc");
        try
        {
            Directory.Delete("lab3/test");
        }
        catch (IOException ex)
        {
            Console.WriteLine("Delete(test) failed: " + ex.GetType().Name);
        }
 
        Directory.Move("lab3/test", "lab3/test2");
        Console.WriteLine("After Move: test={0} test2={1}",
            Directory.Exists("lab3/test"), Directory.Exists("lab3/test2"));
 
        Directory.Delete("lab3/test2", true);
        Console.WriteLine("After Delete(test2, true): " + Directory.Exists("lab3/test2"));
    }
}

Name: test, Parent: lab3
Exists: True
Current directory: D:\a\os1-lab-runner\os1-lab-runner\labs\os1-03-p16-dirbasics
Root: D:\
Drives: C:\ D:\
Delete(test) failed: IOException
After Move: test=False test2=True
After Delete(test2, true): False

    static void MakeSampleTree()
    {
        if (Directory.Exists("site")) Directory.Delete("site", true);
        Directory.CreateDirectory("site/images");
        Directory.CreateDirectory("site/wiki/old");
        File.WriteAllText("site/about.txt", "Streams move bytes between a program and a file.");
        File.WriteAllText("site/work.txt", "Lab work list");
        File.WriteAllBytes("site/images/logo.bin", new byte[300]);
        File.WriteAllText("site/wiki/home.txt", "Welcome to the wiki");
        File.WriteAllText("site/wiki/week1.txt", "Week 1: what is a stream?");
        File.WriteAllText("site/wiki/old/week0.txt", "Week 0: setup");
    }

site
    about.txt        48 bytes   "Streams move bytes between a program and a file."
    work.txt         13 bytes   "Lab work list"
    images
        logo.bin    300 bytes   (300 zero bytes)
    wiki
        home.txt     19 bytes   "Welcome to the wiki"
        week1.txt    25 bytes   "Week 1: what is a stream?"
        old
            week0.txt  13 bytes "Week 0: setup"

using System;
using System.IO;
 
class Program
{
    static void MakeSampleTree()
    {
        if (Directory.Exists("site")) Directory.Delete("site", true);
        Directory.CreateDirectory("site/images");
        Directory.CreateDirectory("site/wiki/old");
        File.WriteAllText("site/about.txt", "Streams move bytes between a program and a file.");
        File.WriteAllText("site/work.txt", "Lab work list");
        File.WriteAllBytes("site/images/logo.bin", new byte[300]);
        File.WriteAllText("site/wiki/home.txt", "Welcome to the wiki");
        File.WriteAllText("site/wiki/week1.txt", "Week 1: what is a stream?");
        File.WriteAllText("site/wiki/old/week0.txt", "Week 0: setup");
    }
 
    static void Show(string title, string[] items)
    {
        Console.WriteLine(title);
        foreach (var item in items) Console.WriteLine("   " + item);
    }
 
    static void Main(string[] args)
    {
        MakeSampleTree();
 
        Show("GetDirectories(site):", Directory.GetDirectories("site"));
        Show("GetDirectories(site, w*, TopDirectoryOnly):",
            Directory.GetDirectories("site", "w*", SearchOption.TopDirectoryOnly));
        Show("GetDirectories(site, *, AllDirectories):",
            Directory.GetDirectories("site", "*", SearchOption.AllDirectories));
        Show("GetFiles(site):", Directory.GetFiles("site"));
        Show("GetFileSystemEntries(site, w*):", Directory.GetFileSystemEntries("site", "w*"));
        Show("GetFiles(site, w*, AllDirectories):",
            Directory.GetFiles("site", "w*", SearchOption.AllDirectories));
 
        Console.WriteLine("FileInfo for every file in site/wiki:");
        DirectoryInfo dirinfo = new DirectoryInfo("site/wiki");
        FileInfo[] filesInDir = dirinfo.GetFiles();
        foreach (FileInfo file in filesInDir)
        {
            Console.WriteLine("   File Name {0} Extension {1} Size: {2} bytes",
                file.Name, file.Extension, file.Length);
        }
    }
}

GetDirectories(site):
   site\images
   site\wiki
GetDirectories(site, w*, TopDirectoryOnly):
   site\wiki
GetDirectories(site, *, AllDirectories):
   site\images
   site\wiki
   site\wiki\old
GetFiles(site):
   site\about.txt
   site\work.txt
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 for every file in site/wiki:
   File Name home.txt Extension .txt Size: 19 bytes
   File Name week1.txt Extension .txt Size: 25 bytes

using System;
using System.IO;
 
class Program
{
    static void MakeSampleTree()
    {
        if (Directory.Exists("site")) Directory.Delete("site", true);
        Directory.CreateDirectory("site/images");
        Directory.CreateDirectory("site/wiki/old");
        File.WriteAllText("site/about.txt", "Streams move bytes between a program and a file.");
        File.WriteAllText("site/work.txt", "Lab work list");
        File.WriteAllBytes("site/images/logo.bin", new byte[300]);
        File.WriteAllText("site/wiki/home.txt", "Welcome to the wiki");
        File.WriteAllText("site/wiki/week1.txt", "Week 1: what is a stream?");
        File.WriteAllText("site/wiki/old/week0.txt", "Week 0: setup");
    }
 
    static void Main(string[] args)
    {
        MakeSampleTree();
        long size = 0;
        var dirInfo = new DirectoryInfo("site");
 
        foreach (FileInfo fi in dirInfo.GetFiles("*", SearchOption.AllDirectories))
        {
            size += fi.Length;
            Console.WriteLine("{0,-10} {1,4} bytes  running total {2,4}", fi.Name, fi.Length, size);
        }
 
        Console.WriteLine($"The directory size: {size} bytes");
        long top = 0;
        foreach (FileInfo fi in dirInfo.GetFiles()) top += fi.Length;
        Console.WriteLine($"Top level files only: {top} bytes");
    }
}

about.txt    48 bytes  running total   48
work.txt     13 bytes  running total   61
logo.bin    300 bytes  running total  361
home.txt     19 bytes  running total  380
week1.txt    25 bytes  running total  405
week0.txt    13 bytes  running total  418
The directory size: 418 bytes
Top level files only: 61 bytes

using System;
using System.IO;
 
class Program
{
    static void MakeSampleTree()
    {
        if (Directory.Exists("site")) Directory.Delete("site", true);
        Directory.CreateDirectory("site/images");
        Directory.CreateDirectory("site/wiki/old");
        File.WriteAllText("site/about.txt", "Streams move bytes between a program and a file.");
        File.WriteAllText("site/work.txt", "Lab work list");
        File.WriteAllBytes("site/images/logo.bin", new byte[300]);
        File.WriteAllText("site/wiki/home.txt", "Welcome to the wiki");
        File.WriteAllText("site/wiki/week1.txt", "Week 1: what is a stream?");
        File.WriteAllText("site/wiki/old/week0.txt", "Week 0: setup");
    }
 
    static void Main(string[] args)
    {
        MakeSampleTree();
        if (Directory.Exists("site-2")) Directory.Delete("site-2", true);
 
        DirectoryCopy("site", "site-2", true);
        Console.WriteLine("Copying finished");
        Console.WriteLine("Files in site-2: " +
            Directory.GetFiles("site-2", "*", SearchOption.AllDirectories).Length);
    }
 
    private static void DirectoryCopy(string source, string dest, bool copySubDirs = true)
    {
        var dir = new DirectoryInfo(source);
 
        if (!dir.Exists)
        {
            throw new DirectoryNotFoundException(
                $"Source directory does not exist or could not be found: {source}");
        }
 
        DirectoryInfo[] dirs = dir.GetDirectories();
 
        if (!Directory.Exists(dest))
        {
            Directory.CreateDirectory(dest);
            Console.WriteLine("create " + dest);
        }
 
        FileInfo[] files = dir.GetFiles();
        foreach (FileInfo file in files)
        {
            string tempPath = Path.Combine(dest, file.Name);
            file.CopyTo(tempPath, false);
            Console.WriteLine("  copy " + tempPath);
        }
 
        if (copySubDirs)
        {
            foreach (DirectoryInfo subdir in dirs)
            {
                string tempPath = Path.Combine(dest, subdir.Name);
                DirectoryCopy(subdir.FullName, tempPath, copySubDirs);
            }
        }
    }
}

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

    private static void DirSearch(string sDir)
    {
        try
        {
            foreach (var directory in Directory.GetDirectories(sDir))
            {
                foreach (var filename in Directory.GetFiles(directory))
                {
                    using (var streamReader = new StreamReader(filename))
                    {
                        var contents = streamReader.ReadToEnd().ToLower();
                        if (contents.Contains(SearchText))
                        {
                            FilesFound.Add(filename);
                        }
                    }
                }
                DirSearch(directory);
            }
        }
        catch (System.Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

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

using System;
using System.IO;
using System.Security.AccessControl;
 
class Program
{
    static void Main(string[] args)
    {
        var myDir = "test";
        Directory.CreateDirectory(myDir);
 
        var dirInfo = new DirectoryInfo(myDir);
        DirectorySecurity dSecurity = dirInfo.GetAccessControl();
        AuthorizationRuleCollection acl = dSecurity.GetAccessRules(true, true,
            typeof(System.Security.Principal.NTAccount));
 
        foreach (FileSystemAccessRule ace in acl)
        {
            Console.WriteLine("Account: {0}", ace.IdentityReference.Value);
            Console.WriteLine("Type: {0}", ace.AccessControlType);
            Console.WriteLine("Rights: {0}", ace.FileSystemRights);
            Console.WriteLine("Inherited: {0}", ace.IsInherited);
            Console.WriteLine("------------------------");
        }
    }
}

Account: BUILTIN\Administrators
Type: Allow
Rights: FullControl
Inherited: False
------------------------
Account: BUILTIN\Administrators
Type: Allow
Rights: FullControl
Inherited: True
------------------------
Account: NT AUTHORITY\SYSTEM
Type: Allow
Rights: FullControl
Inherited: True
------------------------
Account: CREATOR OWNER
Type: Allow
Rights: 268435456
Inherited: True
------------------------
Account: BUILTIN\Users
Type: Allow
Rights: ReadAndExecute, Synchronize
Inherited: True
------------------------
Account: BUILTIN\Users
Type: Allow
Rights: CreateDirectories
Inherited: True
------------------------
Account: BUILTIN\Users
Type: Allow
Rights: CreateFiles
Inherited: True
------------------------

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

using (var bw = new BinaryWriter(new FileStream("rec.bin", FileMode.Create)))
{
    bw.Write(7);
    bw.Write(true);
    bw.Write(3.5);
    bw.Write(false);
    bw.Write(1000);
}

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        File.WriteAllText("data.txt", "STREAM");
        using (var fs = new FileStream("data.txt", FileMode.Open, FileAccess.ReadWrite))
        {
            Console.WriteLine("1) ReadByte() = {0}, Position = {1}", fs.ReadByte(), fs.Position);
            Console.WriteLine("2) ReadByte() = {0}, Position = {1}", fs.ReadByte(), fs.Position);
            fs.Seek(2, SeekOrigin.Current);
            Console.WriteLine("3) Seek(2, Current): Position = {0}", fs.Position);
            fs.WriteByte(33);
            Console.WriteLine("4) WriteByte(33): Position = {0}, Length = {1}", fs.Position, fs.Length);
            fs.Seek(-1, SeekOrigin.End);
            Console.WriteLine("5) Seek(-1, End): Position = {0}", fs.Position);
            Console.WriteLine("6) ReadByte() = {0}, Position = {1}", fs.ReadByte(), fs.Position);
            Console.WriteLine("7) ReadByte() = {0}, Position = {1}", fs.ReadByte(), fs.Position);
            fs.Seek(8, SeekOrigin.Begin);
            fs.WriteByte(90);
            Console.WriteLine("8) Seek(8, Begin), WriteByte(90): Position = {0}, Length = {1}", fs.Position, fs.Length);
        }
        Console.WriteLine("Bytes: " + string.Join(" ", File.ReadAllBytes("data.txt")));
    }
}

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

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        // (a) a log that grows by one line on every run
        if (File.Exists("log.txt")) File.Delete("log.txt");
        for (int run = 1; run <= 3; run++)
        {
            using var w = new StreamWriter(new FileStream("log.txt", FileMode.Append, FileAccess.Write));
            w.WriteLine("run " + run);
        }
        Console.WriteLine("(a) log.txt has " + File.ReadAllLines("log.txt").Length + " lines");
 
        // (b) CreateNew twice
        if (File.Exists("new.txt")) File.Delete("new.txt");
        for (int i = 1; i <= 2; i++)
        {
            try
            {
                using var fs = new FileStream("new.txt", FileMode.CreateNew, FileAccess.Write);
                Console.WriteLine("(b) attempt " + i + ": created");
            }
            catch (Exception ex)
            {
                Console.WriteLine("(b) attempt " + i + ": " + ex.GetType().Name);
            }
        }
 
        // (c) Open + Write over HELLO
        File.WriteAllText("hello.txt", "HELLO");
        using (var fs = new FileStream("hello.txt", FileMode.Open, FileAccess.Write))
        {
            fs.WriteByte((byte)'J');
        }
        Console.WriteLine("(c) hello.txt holds " + File.ReadAllText("hello.txt"));
 
        // (d) Truncate + Read
        try
        {
            using var fs = new FileStream("hello.txt", FileMode.Truncate, FileAccess.Read);
            Console.WriteLine("(d) opened");
        }
        catch (Exception ex)
        {
            Console.WriteLine("(d) " + ex.GetType().Name);
        }
        Console.WriteLine("(d) hello.txt still holds " + File.ReadAllText("hello.txt"));
    }
}

(a) log.txt has 3 lines
(b) attempt 1: created
(b) attempt 2: IOException
(c) hello.txt holds JELLO
(d) ArgumentException
(d) hello.txt still holds JELLO

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        using (var bw = new BinaryWriter(new FileStream("rec.bin", FileMode.Create)))
        {
            bw.Write(7);
            bw.Write(true);
            bw.Write(3.5);
            bw.Write(false);
            bw.Write(1000);
        }
        Console.WriteLine("Size: " + new FileInfo("rec.bin").Length + " bytes");
 
        using (var br = new BinaryReader(new FileStream("rec.bin", FileMode.Open)))
        {
            Console.WriteLine(br.ReadInt32() + " " + br.ReadBoolean() + " " + br.ReadDouble() + " "
                + br.ReadBoolean() + " " + br.ReadInt32());
        }
        byte[] raw = File.ReadAllBytes("rec.bin");
        Console.WriteLine("Last 4 bytes: {0} {1} {2} {3}", raw[14], raw[15], raw[16], raw[17]);
    }
}

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

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        using (StreamWriter sw = new StreamWriter("os.txt"))
        {
            sw.WriteLine("Windows");
            sw.WriteLine("Linux");
            sw.WriteLine("macOS");
            sw.WriteLine("FreeBSD");
            sw.WriteLine("Android");
        }
 
        int count = 0;
        string longest = "";
        using (StreamReader sr = new StreamReader("os.txt"))
        {
            string line = sr.ReadLine();
            while (line != null)
            {
                count++;
                if (line.Length > longest.Length) longest = line;
                line = sr.ReadLine();
            }
        }
        Console.WriteLine("Lines: " + count);
        Console.WriteLine("Longest: " + longest + " (" + longest.Length + " characters)");
        Console.WriteLine("File size: " + new FileInfo("os.txt").Length + " bytes");
    }
}

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

using System;
using System.IO;
 
class Program
{
    static void MakeSampleTree()
    {
        if (Directory.Exists("site")) Directory.Delete("site", true);
        Directory.CreateDirectory("site/images");
        Directory.CreateDirectory("site/wiki/old");
        File.WriteAllText("site/about.txt", "Streams move bytes between a program and a file.");
        File.WriteAllText("site/work.txt", "Lab work list");
        File.WriteAllBytes("site/images/logo.bin", new byte[300]);
        File.WriteAllText("site/wiki/home.txt", "Welcome to the wiki");
        File.WriteAllText("site/wiki/week1.txt", "Week 1: what is a stream?");
        File.WriteAllText("site/wiki/old/week0.txt", "Week 0: setup");
    }
 
    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;
    }
 
    static void Main(string[] args)
    {
        MakeSampleTree();
        long total = PrintTree(new DirectoryInfo("site"), "");
        Console.WriteLine("Total: " + total + " bytes");
        long wiki = 0;
        foreach (FileInfo fi in new DirectoryInfo("site/wiki").GetFiles("*", SearchOption.AllDirectories))
            wiki += fi.Length;
        Console.WriteLine("wiki: " + wiki + " bytes");
    }
}