Files, Directories and Streams

Option Strict On
Imports System.IO
Imports System.Text

Module Ex01
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim shelfFile As String = Path.Combine(root, "shelf.txt")

            ' Write, append, read: the one-call File methods.
            File.WriteAllText(shelfFile, "Dune" & vbLf & "Emma" & vbLf)
            File.AppendAllText(shelfFile, "Ulysses" & Environment.NewLine)
            File.AppendAllLines(shelfFile, {"Hamlet", "Beloved"})

            Dim lines As String() = File.ReadAllLines(shelfFile)
            Console.WriteLine($"ReadAllLines: {lines.Length} lines, first={lines(0)}, last={lines(lines.Length - 1)}")
            Console.WriteLine($"ReadAllText length: {File.ReadAllText(shelfFile).Length}")

            ' ReadLines is lazy: it streams, and the file stays open until the enumeration ends.
            Dim longTitles As Integer = 0
            For Each title As String In File.ReadLines(shelfFile)
                If title.Length > 5 Then longTitles += 1
            Next
            Console.WriteLine($"Titles longer than 5 characters: {longTitles}")

            ' Existence, copy, move, delete.
            Dim backup As String = Path.Combine(root, "shelf.bak")
            File.Copy(shelfFile, backup)
            Console.WriteLine($"Exists: {File.Exists(shelfFile)} {File.Exists(backup)} {File.Exists(Path.Combine(root, "nope.txt"))}")
            Try
                File.Copy(shelfFile, backup)
            Catch ex As IOException
                Console.WriteLine($"Copy over existing file: {ex.GetType().Name}")
            End Try
            File.Copy(shelfFile, backup, overwrite:=True)
            Dim moved As String = Path.Combine(root, "archive.txt")
            File.Move(backup, moved)
            Console.WriteLine($"After move: {File.Exists(backup)} {File.Exists(moved)}")
            File.Delete(moved)
            File.Delete(moved) ' Deleting a file that does not exist is not an error.
            Console.WriteLine($"After delete: {File.Exists(moved)}")

            ' Metadata without opening the file.
            Console.WriteLine($"Length of shelf.txt in bytes: {New FileInfo(shelfFile).Length}")
            Console.WriteLine($"Attributes: {File.GetAttributes(shelfFile)}")
            File.SetLastWriteTimeUtc(shelfFile, New Date(2026, 1, 15, 8, 30, 0, DateTimeKind.Utc))
            Console.WriteLine($"Last write (UTC): {File.GetLastWriteTimeUtc(shelfFile):yyyy-MM-dd HH:mm}")

            ' Bytes.
            File.WriteAllBytes(Path.Combine(root, "raw.bin"), {&H44, &H75, &H6E, &H65})
            Console.WriteLine($"Bytes as text: {Encoding.UTF8.GetString(File.ReadAllBytes(Path.Combine(root, "raw.bin")))}")

            ' The errors you meet.
            Try
                File.ReadAllText(Path.Combine(root, "missing.txt"))
            Catch ex As FileNotFoundException
                Console.WriteLine($"FileNotFoundException, FileName ends with: {Path.GetFileName(ex.FileName)}")
            End Try
            Try
                File.ReadAllText(Path.Combine(root, "no-such-dir", "x.txt"))
            Catch ex As DirectoryNotFoundException
                Console.WriteLine("DirectoryNotFoundException for a missing folder")
            End Try
            Try
                File.ReadAllText(root)
            Catch ex As UnauthorizedAccessException
                Console.WriteLine("UnauthorizedAccessException when the path is a directory")
            End Try
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

ReadAllLines: 5 lines, first=Dune, last=Beloved
ReadAllText length: 33
Titles longer than 5 characters: 3
Exists: True True False
Copy over existing file: IOException
After move: False True
After delete: False
Length of shelf.txt in bytes: 33
Attributes: Normal
Last write (UTC): 2026-01-15 08:30
Bytes as text: Dune
FileNotFoundException, FileName ends with: missing.txt
DirectoryNotFoundException for a missing folder
UnauthorizedAccessException when the path is a directory

Option Strict On
Imports System.IO

Module Ex02
    Sub Main()
        ' Path works on strings only: it never touches the disk.
        Dim full As String = Path.Combine("data", "shelf", "books.csv")
        Console.WriteLine($"Combine: {full.Replace(Path.DirectorySeparatorChar, "/"c)}")
        Console.WriteLine($"Separator: {Path.DirectorySeparatorChar}  Alt: {Path.AltDirectorySeparatorChar}  PathSeparator: {Path.PathSeparator}")
        Console.WriteLine($"GetFileName: {Path.GetFileName(full)}")
        Console.WriteLine($"GetFileNameWithoutExtension: {Path.GetFileNameWithoutExtension(full)}")
        Console.WriteLine($"GetExtension: {Path.GetExtension(full)}")
        Console.WriteLine($"GetDirectoryName: {Path.GetDirectoryName(full)?.Replace(Path.DirectorySeparatorChar, "/"c)}")
        Console.WriteLine($"ChangeExtension: {Path.ChangeExtension(full, ".json").Replace(Path.DirectorySeparatorChar, "/"c)}")
        Console.WriteLine($"HasExtension: {Path.HasExtension("README")} {Path.HasExtension("a.md")}")
        Console.WriteLine($"IsPathRooted: {Path.IsPathRooted(full)} {Path.IsPathRooted("/etc")}")

        ' Combine discards everything before a rooted argument; Join does not.
        Console.WriteLine($"Combine with rooted part: {Path.Combine("data", "/etc/passwd")}")
        Console.WriteLine($"Join with rooted part:    {Path.Join("data", "/etc/passwd")}")

        ' Relative paths.
        Dim a As String = Path.GetFullPath("/srv/shelf/data/books.csv")
        Dim b As String = "/srv/shelf"
        Console.WriteLine($"GetRelativePath: {Path.GetRelativePath(b, a)}")

        ' Random and temporary names.
        Console.WriteLine($"GetRandomFileName length: {Path.GetRandomFileName().Length}")
        Dim tempName As String = Path.GetTempFileName()
        Console.WriteLine($"GetTempFileName created a file: {File.Exists(tempName)}")
        File.Delete(tempName)

        ' Invalid characters depend on the operating system.
        Console.WriteLine($"Invalid file-name characters on this OS: {Path.GetInvalidFileNameChars().Length}")

        ' Directory and DirectoryInfo.
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Try
            Directory.CreateDirectory(Path.Combine(root, "catalog", "2026"))
            Directory.CreateDirectory(Path.Combine(root, "catalog", "2025"))
            File.WriteAllText(Path.Combine(root, "catalog", "books.csv"), "x")
            File.WriteAllText(Path.Combine(root, "catalog", "2026", "new.csv"), "x")
            File.WriteAllText(Path.Combine(root, "catalog", "2026", "notes.txt"), "x")
            File.WriteAllText(Path.Combine(root, "catalog", "2025", "old.csv"), "x")

            Dim catalog As String = Path.Combine(root, "catalog")
            Console.WriteLine("Top-level entries:")
            For Each entry As String In Directory.EnumerateFileSystemEntries(catalog).OrderBy(Function(s) s, StringComparer.Ordinal)
                Console.WriteLine("  " & Path.GetRelativePath(root, entry).Replace(Path.DirectorySeparatorChar, "/"c))
            Next
            Console.WriteLine("All CSV files, recursively:")
            For Each csvFile As String In Directory.EnumerateFiles(catalog, "*.csv", SearchOption.AllDirectories).OrderBy(Function(s) s, StringComparer.Ordinal)
                Console.WriteLine("  " & Path.GetRelativePath(root, csvFile).Replace(Path.DirectorySeparatorChar, "/"c))
            Next
            Console.WriteLine($"Directories: {String.Join(", ", Directory.GetDirectories(catalog).Select(Function(d) Path.GetFileName(d)).OrderBy(Function(s) s, StringComparer.Ordinal))}")

            Dim info As New DirectoryInfo(catalog)
            Console.WriteLine($"DirectoryInfo: Name={info.Name}, Parent={info.Parent?.Name?.StartsWith("shelf-")}, Exists={info.Exists}")
            Dim total As Long = info.EnumerateFiles("*", SearchOption.AllDirectories).Sum(Function(f) f.Length)
            Console.WriteLine($"Total size: {total} bytes in {info.GetFiles("*", SearchOption.AllDirectories).Length} files")

            ' Deleting a non-empty directory needs recursive:=True.
            Try
                Directory.Delete(catalog)
            Catch ex As IOException
                Console.WriteLine($"Delete non-empty directory: {ex.GetType().Name}")
            End Try
            Directory.Delete(catalog, recursive:=True)
            Console.WriteLine($"Catalog exists after recursive delete: {Directory.Exists(catalog)}")
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

Combine: data/shelf/books.csv
Separator: /  Alt: /  PathSeparator: :
GetFileName: books.csv
GetFileNameWithoutExtension: books
GetExtension: .csv
GetDirectoryName: data/shelf
ChangeExtension: data/shelf/books.json
HasExtension: False True
IsPathRooted: False True
Combine with rooted part: /etc/passwd
Join with rooted part:    data/etc/passwd
GetRelativePath: data/books.csv
GetRandomFileName length: 12
GetTempFileName created a file: True
Invalid file-name characters on this OS: 2
Top-level entries:
  catalog/2025
  catalog/2026
  catalog/books.csv
All CSV files, recursively:
  catalog/2025/old.csv
  catalog/2026/new.csv
  catalog/books.csv
Directories: 2025, 2026
DirectoryInfo: Name=catalog, Parent=True, Exists=True
Total size: 4 bytes in 4 files
Delete non-empty directory: IOException
Catalog exists after recursive delete: False

Option Strict On
Imports System.IO
Imports System.Text

Module Ex03
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim report As String = Path.Combine(root, "report.txt")

            ' StreamWriter / StreamReader: text, line by line. Using closes (and flushes) the file.
            Using writer As New StreamWriter(report, append:=False, encoding:=New UTF8Encoding(encoderShouldEmitUTF8Identifier:=False))
                writer.WriteLine("Shelf report")
                writer.WriteLine($"{"Dune",-10}{3,5}")
                writer.Write("Total: ")
                writer.WriteLine(3)
            End Using

            Using reader As New StreamReader(report)
                Dim lineNumber As Integer = 0
                Dim line As String = reader.ReadLine()
                Do While line IsNot Nothing
                    lineNumber += 1
                    Console.WriteLine($"{lineNumber}: {line}")
                    line = reader.ReadLine()
                Loop
                Console.WriteLine($"EndOfStream: {reader.EndOfStream}")
            End Using

            ' FileStream gives full control: mode, access, sharing, position.
            Dim dataFile As String = Path.Combine(root, "data.bin")
            Using stream As New FileStream(dataFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None)
                stream.Write(Encoding.ASCII.GetBytes("ABCDEFGHIJ"))
                Console.WriteLine($"Position after write: {stream.Position}, Length: {stream.Length}")
                stream.Seek(2, SeekOrigin.Begin)
                Dim buffer(2) As Byte
                Dim read As Integer = stream.Read(buffer, 0, buffer.Length)
                Console.WriteLine($"Read {read} bytes: {Encoding.ASCII.GetString(buffer)}")
                stream.Seek(-1, SeekOrigin.End)
                stream.WriteByte(CByte(Asc("Z")))
                stream.SetLength(8)
            End Using
            Console.WriteLine($"File content: {File.ReadAllText(dataFile)}")

            ' FileMode behaviours.
            Try
                Using s As New FileStream(dataFile, FileMode.CreateNew)
                End Using
            Catch ex As IOException
                Console.WriteLine($"FileMode.CreateNew on existing file: {ex.GetType().Name}")
            End Try
            Try
                Using s As New FileStream(Path.Combine(root, "absent.bin"), FileMode.Open)
                End Using
            Catch ex As FileNotFoundException
                Console.WriteLine("FileMode.Open on missing file: FileNotFoundException")
            End Try
            Using s As New FileStream(dataFile, FileMode.Append, FileAccess.Write)
                s.Write(Encoding.ASCII.GetBytes("++"))
            End Using
            Console.WriteLine($"After Append: {File.ReadAllText(dataFile)}")
            Using s As New FileStream(dataFile, FileMode.Truncate, FileAccess.Write)
            End Using
            Console.WriteLine($"After Truncate: length {New FileInfo(dataFile).Length}")

            ' Sharing: a second writer is refused while the first is open.
            Using first As New FileStream(dataFile, FileMode.Open, FileAccess.ReadWrite, FileShare.None)
                Try
                    Using second As New FileStream(dataFile, FileMode.Open, FileAccess.Read, FileShare.Read)
                    End Using
                Catch ex As IOException
                    Console.WriteLine($"Second open while locked: {ex.GetType().Name}")
                End Try
            End Using
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

1: Shelf report
2: Dune          3
3: Total: 3
EndOfStream: True
Position after write: 10, Length: 10
Read 3 bytes: CDE
File content: ABCDEFGH
FileMode.CreateNew on existing file: IOException
FileMode.Open on missing file: FileNotFoundException
After Append: ABCDEFGH++
After Truncate: length 0
Second open while locked: IOException

Option Strict On
Imports System.IO

Module Ex04
    ' The classic leak: File.Create returns an open FileStream that nobody disposes.
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim target As String = Path.Combine(root, "leak.txt")

            ' Wrong: the returned FileStream stays open until the garbage collector finalizes it.
            Dim leaked As FileStream = File.Create(target)
            Try
                File.WriteAllText(target, "second writer")
            Catch ex As IOException
                Console.WriteLine($"Leak: writing the file again fails with {ex.GetType().Name}")
            End Try
            leaked.Dispose()
            File.WriteAllText(target, "after dispose")
            Console.WriteLine($"After Dispose: {File.ReadAllText(target)}")

            ' Right: Using disposes the stream at End Using, even when an exception is thrown.
            Using created As FileStream = File.Create(target)
                created.WriteByte(65)
            End Using
            File.WriteAllText(target, "ok")
            Console.WriteLine($"With Using: {File.ReadAllText(target)}")

            ' Even simpler: one-call helpers never leave a stream open.
            File.WriteAllText(target, "helpers close the file")
            Console.WriteLine(File.ReadAllText(target))

            ' Dispose order: the writer owns the stream, so disposing the writer is enough.
            Dim fs As New FileStream(target, FileMode.Create)
            Using writer As New StreamWriter(fs)
                writer.Write("owned")
            End Using
            Console.WriteLine($"Stream CanWrite after the writer was disposed: {fs.CanWrite}")
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

Leak: writing the file again fails with IOException
After Dispose: after dispose
With Using: ok
helpers close the file
Stream CanWrite after the writer was disposed: False

Option Strict On
Imports System.IO
Imports System.Text

Module Ex05
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim text As String = "Cien años de soledad"
            Dim names As String() = {"utf8", "utf8bom", "utf16", "utf16be", "latin1", "ascii"}
            Dim encodings As Encoding() = {
                New UTF8Encoding(False), New UTF8Encoding(True), Encoding.Unicode,
                Encoding.BigEndianUnicode, Encoding.Latin1, Encoding.ASCII}

            For i As Integer = 0 To names.Length - 1
                Dim path1 As String = Path.Combine(root, names(i) & ".txt")
                File.WriteAllText(path1, text, encodings(i))
                Dim bytes As Byte() = File.ReadAllBytes(path1)
                Console.WriteLine($"{names(i),-8} {bytes.Length,3} bytes, starts {Convert.ToHexString(bytes, 0, 4)}, default read: {File.ReadAllText(path1)}")
            Next

            ' Reading with the wrong encoding gives mojibake, not an exception.
            Dim latinPath As String = Path.Combine(root, "latin1.txt")
            Console.WriteLine($"Latin-1 file read as UTF-8: {File.ReadAllText(latinPath, New UTF8Encoding(False, throwOnInvalidBytes:=False))}")
            Try
                File.ReadAllText(latinPath, New UTF8Encoding(False, throwOnInvalidBytes:=True))
            Catch ex As DecoderFallbackException
                Console.WriteLine("Strict UTF-8 refuses the Latin-1 bytes: DecoderFallbackException")
            End Try

            ' StreamReader detects a byte order mark by default and tells you what it found.
            Using reader As New StreamReader(Path.Combine(root, "utf16.txt"))
                reader.Peek()
                Console.WriteLine($"Detected from BOM: {reader.CurrentEncoding.EncodingName}")
            End Using
            Using reader As New StreamReader(Path.Combine(root, "utf16.txt"), Encoding.Latin1, detectEncodingFromByteOrderMarks:=False)
                Console.WriteLine($"UTF-16 file read as Latin-1 (no detection), first line length: {reader.ReadLine().Length}")
            End Using

            ' Characters that the encoding cannot represent are replaced.
            File.WriteAllText(Path.Combine(root, "ascii2.txt"), "Ñandú", Encoding.ASCII)
            Console.WriteLine($"Written as ASCII: {File.ReadAllText(Path.Combine(root, "ascii2.txt"))}")

            ' Code pages beyond the built-in ones need the System.Text.Encoding.CodePages provider.
            Try
                Console.WriteLine(Encoding.GetEncoding(1252).EncodingName)
            Catch ex As NotSupportedException
                Console.WriteLine($"GetEncoding(1252) without the provider: {ex.GetType().Name}")
            End Try
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance)
            Console.WriteLine($"After RegisterProvider: {Encoding.GetEncoding(1252).EncodingName}")
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

utf8      21 bytes, starts 4369656E, default read: Cien años de soledad
utf8bom   24 bytes, starts EFBBBF43, default read: Cien años de soledad
utf16     42 bytes, starts FFFE4300, default read: Cien años de soledad
utf16be   42 bytes, starts FEFF0043, default read: Cien años de soledad
latin1    20 bytes, starts 4369656E, default read: Cien a�os de soledad
ascii     20 bytes, starts 4369656E, default read: Cien a?os de soledad
Latin-1 file read as UTF-8: Cien a�os de soledad
Strict UTF-8 refuses the Latin-1 bytes: DecoderFallbackException
Detected from BOM: Unicode
UTF-16 file read as Latin-1 (no detection), first line length: 42
Written as ASCII: ?and?
GetEncoding(1252) without the provider: NotSupportedException
After RegisterProvider: Western European (Windows)

Option Strict On
Imports System.IO
Imports System.Threading

Module Ex06
    Sub Main()
        ' Visual Basic has no Async Main: bridge from Sub Main.
        RunAsync().GetAwaiter().GetResult()
    End Sub

    Private Async Function RunAsync() As Task
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim target As String = Path.Combine(root, "loans.txt")
            Dim lines As String() = {"978-0-441-17271-9,Dune,2026-01-05", "978-0-14-143951-8,Emma,2026-01-09", "978-0-14-243724-7,Beloved,2026-01-12"}

            Await File.WriteAllLinesAsync(target, lines)
            Dim readBack As String() = Await File.ReadAllLinesAsync(target)
            Console.WriteLine($"Round trip: {readBack.Length} lines")

            ' Stream with useAsync:=True (FileOptions.Asynchronous) for real overlapped I/O.
            Using stream As New FileStream(target, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync:=True)
                Using reader As New StreamReader(stream)
                    Dim count As Integer = 0
                    Dim line As String = Await reader.ReadLineAsync()
                    Do While line IsNot Nothing
                        count += 1
                        line = Await reader.ReadLineAsync()
                    Loop
                    Console.WriteLine($"Counted {count} lines asynchronously")
                End Using
            End Using

            ' Several files in parallel with Task.WhenAll.
            Dim names As String() = {"a.txt", "b.txt", "c.txt"}
            Dim writes As New List(Of Task)()
            For Each name As String In names
                writes.Add(File.WriteAllTextAsync(Path.Combine(root, name), "file " & name))
            Next
            Await Task.WhenAll(writes)
            Dim reads As New List(Of Task(Of String))()
            For Each name As String In names
                reads.Add(File.ReadAllTextAsync(Path.Combine(root, name)))
            Next
            Dim all As String() = Await Task.WhenAll(reads)
            Console.WriteLine(String.Join(" | ", all))

            ' Streaming with an enumerator (VB has no Await For Each).
            Dim enumerator As IAsyncEnumerator(Of String) = File.ReadLinesAsync(target).GetAsyncEnumerator()
            Dim titles As New List(Of String)()
            Do While Await enumerator.MoveNextAsync()
                titles.Add(enumerator.Current.Split(","c)(1))
            Loop
            Await enumerator.DisposeAsync() ' Await is not allowed in Finally, so there is no Try/Finally here
            Console.WriteLine("ReadLinesAsync titles: " & String.Join(", ", titles))

            ' Cancellation.
            Using cts As New CancellationTokenSource()
                cts.Cancel()
                Try
                    Await File.ReadAllTextAsync(target, cts.Token)
                Catch ex As OperationCanceledException
                    Console.WriteLine($"Cancelled before reading: {ex.GetType().Name}")
                End Try
            End Using
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Function
End Module

Round trip: 3 lines
Counted 3 lines asynchronously
file a.txt | file b.txt | file c.txt
ReadLinesAsync titles: Dune, Emma, Beloved
Cancelled before reading: TaskCanceledException

Option Strict On
Imports System.IO
Imports System.Threading

Module Ex07
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim seen As New System.Collections.Concurrent.ConcurrentQueue(Of String)()
            Dim renamed As New ManualResetEventSlim(False)

            Using watcher As New FileSystemWatcher(root, "*.csv")
                watcher.NotifyFilter = NotifyFilters.FileName Or NotifyFilters.LastWrite
                watcher.IncludeSubdirectories = False

                ' Handlers run on a thread-pool thread, not on the thread that called Main.
                AddHandler watcher.Created, Sub(sender As Object, e As FileSystemEventArgs) seen.Enqueue("Created " & e.Name)
                AddHandler watcher.Deleted, Sub(sender As Object, e As FileSystemEventArgs) seen.Enqueue("Deleted " & e.Name)
                AddHandler watcher.Renamed, Sub(sender As Object, e As RenamedEventArgs)
                                                seen.Enqueue("Renamed " & e.OldName & " -> " & e.Name)
                                                renamed.Set()
                                            End Sub
                AddHandler watcher.Error, Sub(sender As Object, e As ErrorEventArgs) seen.Enqueue("Error " & e.GetException().GetType().Name)
                watcher.EnableRaisingEvents = True

                File.WriteAllText(Path.Combine(root, "books.csv"), "x")
                File.WriteAllText(Path.Combine(root, "notes.txt"), "ignored: the filter is *.csv")
                Thread.Sleep(300)
                File.Move(Path.Combine(root, "books.csv"), Path.Combine(root, "catalog.csv"))
                renamed.Wait(TimeSpan.FromSeconds(5))
                File.Delete(Path.Combine(root, "catalog.csv"))
                Thread.Sleep(500)
            End Using

            For Each entry As String In seen
                Console.WriteLine(entry)
            Next
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

Created books.csv
Renamed books.csv -> catalog.csv
Deleted catalog.csv

Option Strict On
Imports System.IO
Imports Microsoft.VisualBasic.FileIO

Module Ex08
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim source As String = Path.Combine(root, "source")
            Dim copyTo As String = Path.Combine(root, "copy")
            ' FileSystem here is Microsoft.VisualBasic.FileIO.FileSystem: all Shared methods, usable from any project.
            FileSystem.CreateDirectory(Path.Combine(source, "sub"))
            FileSystem.WriteAllText(Path.Combine(source, "a.txt"), "alpha", append:=False)
            FileSystem.WriteAllText(Path.Combine(source, "a.txt"), " beta", append:=True)
            FileSystem.WriteAllText(Path.Combine(source, "sub", "b.log"), "log", append:=False)
            Console.WriteLine($"ReadAllText: {FileSystem.ReadAllText(Path.Combine(source, "a.txt"))}")

            ' Recursive copy in one call. The overloads that take a UIOption show Windows shell dialogs.
            Try
                FileSystem.CopyDirectory(source, copyTo, UIOption.OnlyErrorDialogs)
            Catch ex As PlatformNotSupportedException
                Console.WriteLine($"CopyDirectory with UIOption: {ex.Message}")
            End Try
            FileSystem.CopyDirectory(source, copyTo)
            Console.WriteLine($"Copied tree: {String.Join(", ", FileSystem.GetFiles(copyTo, FileIO.SearchOption.SearchAllSubDirectories).Select(Function(f) Path.GetRelativePath(copyTo, f).Replace(Path.DirectorySeparatorChar, "/"c)).OrderBy(Function(s) s, StringComparer.Ordinal))}")

            ' Wildcards are a filter list, not a single pattern.
            Dim logs As IEnumerable(Of String) = FileSystem.GetFiles(source, FileIO.SearchOption.SearchAllSubDirectories, "*.log")
            Console.WriteLine($"GetFiles *.log: {logs.Count()}")
            Dim hits As IEnumerable(Of String) = FileSystem.FindInFiles(source, "alpha", ignoreCase:=True, searchType:=FileIO.SearchOption.SearchAllSubDirectories)
            Console.WriteLine($"FindInFiles 'alpha': {hits.Count()} file(s)")

            ' Rename changes only the name; MoveFile changes the folder.
            FileSystem.RenameFile(Path.Combine(copyTo, "a.txt"), "renamed.txt")
            FileSystem.MoveFile(Path.Combine(copyTo, "renamed.txt"), Path.Combine(copyTo, "sub", "moved.txt"), overwrite:=True)
            Console.WriteLine($"Moved: {FileSystem.FileExists(Path.Combine(copyTo, "sub", "moved.txt"))}")

            ' The destination must not be inside the source.
            Try
                FileSystem.CopyDirectory(source, Path.Combine(source, "sub"))
            Catch ex As InvalidOperationException
                Console.WriteLine($"CopyDirectory into itself: {ex.GetType().Name}")
            End Try

            ' Metadata helpers.
            Dim info As FileInfo = FileSystem.GetFileInfo(Path.Combine(source, "a.txt"))
            Console.WriteLine($"GetFileInfo: {info.Name}, {info.Length} bytes")
            Console.WriteLine($"GetName/GetParentPath: {FileSystem.GetName("/x/y/z.txt")} {FileSystem.GetParentPath("/x/y/z.txt")}")
            Console.WriteLine($"CombinePath: {FileSystem.CombinePath("/data", "b.txt").Replace(Path.DirectorySeparatorChar, "/"c)}")

            ' Deleting: the recycle bin is a Windows concept.
            Try
                FileSystem.DeleteFile(Path.Combine(source, "a.txt"), UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin)
                Console.WriteLine($"Delete with SendToRecycleBin: exists afterwards = {File.Exists(Path.Combine(source, "a.txt"))}")
            Catch ex As PlatformNotSupportedException
                Console.WriteLine($"SendToRecycleBin: {ex.GetType().Name}: {ex.Message}")
            End Try
            FileSystem.DeleteFile(Path.Combine(source, "a.txt"))
            FileSystem.DeleteDirectory(source, DeleteDirectoryOption.DeleteAllContents)
            Console.WriteLine($"Deleted tree: {Not Directory.Exists(source)}")
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

ReadAllText: alpha beta
CopyDirectory with UIOption: UI not available for copy or move
Copied tree: a.txt, sub/b.log
GetFiles *.log: 1
FindInFiles 'alpha': 1 file(s)
Moved: True
CopyDirectory into itself: InvalidOperationException
GetFileInfo: a.txt, 13 bytes
GetName/GetParentPath: z.txt /x/y
CombinePath: /data/b.txt
SendToRecycleBin: PlatformNotSupportedException: UI not available for copy or move
Deleted tree: True

Option Strict On
Imports System.IO
Imports Microsoft.VisualBasic.FileIO

Module Ex20
    Sub Main()
        Dim found As IEnumerable(Of String) = FileSystem.GetFiles(".", SearchOption.AllDirectories, "*.vb")
    End Sub
End Module

Ex20.vb(7,72): error BC30561: 'SearchOption' is ambiguous, imported from the namespaces or types 'System.IO, Microsoft.VisualBasic.FileIO'.

Option Strict On
Imports System.IO

Module Ex15
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Try
            ' My.Computer.FileSystem is the same API as Microsoft.VisualBasic.FileIO.FileSystem, reached through My.
            My.Computer.FileSystem.CreateDirectory(root)
            Dim target As String = My.Computer.FileSystem.CombinePath(root, "note.txt")
            My.Computer.FileSystem.WriteAllText(target, "from My.Computer", append:=False)
            Console.WriteLine(My.Computer.FileSystem.ReadAllText(target))
            Console.WriteLine($"Drives reported: {My.Computer.FileSystem.Drives.Count > 0}")
            Console.WriteLine($"Special directory Temp is set: {My.Computer.FileSystem.SpecialDirectories.Temp.Length > 0}")
        Finally
            If My.Computer.FileSystem.DirectoryExists(root) Then
                My.Computer.FileSystem.DeleteDirectory(root, FileIO.DeleteDirectoryOption.DeleteAllContents)
            End If
        End Try
    End Sub
End Module

Option Strict On
Imports System.IO

Module Ex16
    Sub Main()
        ' With the default console MyType, My.Computer is not available.
        My.Computer.FileSystem.WriteAllText("x.txt", "x", False)
    End Sub
End Module

Ex16.vb(7,9): error BC30456: 'Computer' is not a member of 'ShelfDocs.My'.

Option Strict On
Imports System.IO
Imports Microsoft.VisualBasic.FileIO

Module Ex21
    Sub Main()
        Using parser As New TextFieldParser(New StringReader("  a , b  ,""c""" & vbLf & "next,line"))
            Console.WriteLine($"TextFieldType={parser.TextFieldType}, HasFieldsEnclosedInQuotes={parser.HasFieldsEnclosedInQuotes}, TrimWhiteSpace={parser.TrimWhiteSpace}")
            Console.WriteLine($"Delimiters is Nothing={parser.Delimiters Is Nothing}, CommentTokens count={parser.CommentTokens.Length}, FieldWidths is Nothing={parser.FieldWidths Is Nothing}")
            Console.WriteLine($"LineNumber before reading={parser.LineNumber}, ErrorLineNumber={parser.ErrorLineNumber}, ErrorLine=[{parser.ErrorLine}]")
            parser.SetDelimiters(",")
            Console.WriteLine("[" & String.Join("][", parser.ReadFields()) & "]")
            Console.WriteLine($"After one record: LineNumber={parser.LineNumber}")
            Console.WriteLine($"ReadToEnd: [{parser.ReadToEnd()}]")
            Console.WriteLine($"EndOfData={parser.EndOfData}")
        End Using
        ' Without delimiters, ReadFields cannot split the line.
        Using parser As New TextFieldParser(New StringReader("a,b"))
            Try
                Console.WriteLine("[" & String.Join("][", parser.ReadFields()) & "]")
            Catch ex As Exception
                Console.WriteLine($"No delimiters: {ex.GetType().Name}: {ex.Message}")
            End Try
        End Using
    End Sub
End Module

TextFieldType=Delimited, HasFieldsEnclosedInQuotes=True, TrimWhiteSpace=True
Delimiters is Nothing=True, CommentTokens count=0, FieldWidths is Nothing=True
LineNumber before reading=1, ErrorLineNumber=-1, ErrorLine=[]
[a][b][c]
After one record: LineNumber=2
ReadToEnd: [next,line]
EndOfData=True
No delimiters: ArgumentException: Unable to read delimited fields because Delimiters is Nothing or empty. (Parameter 'Delimiters')

Option Strict On
Imports System.IO
Imports Microsoft.VisualBasic.FileIO

Module Ex09
    Sub Main()
        ' The book list as RFC 4180 CSV: a header, a quoted field with a comma, an escaped quote and an embedded line break.
        Dim csv As String =
            "Isbn,Title,Author,Year" & vbCrLf &
            "978-0-441-17271-9,Dune,Frank Herbert,1965" & vbCrLf &
            "978-0-14-143951-8,""Emma, a Novel"",Jane Austen,1815" & vbCrLf &
            "978-0-14-243724-7,""The """"Beloved"""" Edition"",Toni Morrison,1987" & vbCrLf &
            "978-0-00-000000-0,""Two" & vbCrLf & "Lines"",Anonymous,2000" & vbCrLf

        Using reader As New StringReader(csv)
            Using parser As New TextFieldParser(reader)
                parser.TextFieldType = FieldType.Delimited
                parser.SetDelimiters(",")
                parser.HasFieldsEnclosedInQuotes = True
                parser.TrimWhiteSpace = True

                Dim header As String() = parser.ReadFields()
                Console.WriteLine($"Header: {String.Join("|", header)}")
                Do While Not parser.EndOfData
                    Dim lineBefore As Long = parser.LineNumber
                    Dim fields As String() = parser.ReadFields()
                    Dim title As String = fields(1).Replace(vbCrLf, "\n")
                    Console.WriteLine($"Line {lineBefore}: {fields.Length} fields, title=[{title}], year={CInt(fields(3))}")
                Loop
                Console.WriteLine($"After the last record: EndOfData={parser.EndOfData}, LineNumber={parser.LineNumber}")
            End Using
        End Using

        ' Other delimiters, comment lines and untrimmed whitespace.
        Dim semicolons As String =
            "# exported from the shelf" & vbLf &
            "Dune ; Frank Herbert ; 1965" & vbLf &
            "Emma;Jane Austen;1815" & vbLf
        Using parser As New TextFieldParser(New StringReader(semicolons))
            parser.SetDelimiters(";", vbTab)
            parser.CommentTokens = New String() {"#"}
            parser.TrimWhiteSpace = False
            Do While Not parser.EndOfData
                Dim fields As String() = parser.ReadFields()
                Console.WriteLine("[" & String.Join("][", fields) & "]")
            Loop
        End Using

        ' ReadLine returns the raw line; PeekChars looks ahead without consuming.
        Using parser As New TextFieldParser(New StringReader("alpha,beta" & vbLf & "gamma,delta"))
            parser.SetDelimiters(",")
            Console.WriteLine($"PeekChars(3): {parser.PeekChars(3)}")
            Console.WriteLine($"ReadLine: {parser.ReadLine()}")
            Console.WriteLine($"ReadFields: {String.Join("|", parser.ReadFields())}")
        End Using

        ' The same parser reads a file: the constructor with a path detects the encoding.
        Dim path1 As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N") & ".csv")
        Try
            File.WriteAllText(path1, csv)
            Using parser As New TextFieldParser(path1)
                parser.SetDelimiters(",")
                parser.ReadFields()
                Dim count As Integer = 0
                Do While Not parser.EndOfData
                    parser.ReadFields()
                    count += 1
                Loop
                Console.WriteLine($"Records in the file: {count}")
            End Using
        Finally
            File.Delete(path1)
        End Try
    End Sub
End Module

Header: Isbn|Title|Author|Year
Line 2: 4 fields, title=[Dune], year=1965
Line 3: 4 fields, title=[Emma, a Novel], year=1815
Line 4: 4 fields, title=[The "Beloved" Edition], year=1987
Line 5: 4 fields, title=[Two\nLines], year=2000
After the last record: EndOfData=True, LineNumber=-1
[Dune ][ Frank Herbert ][ 1965]
[Emma][Jane Austen][1815]
PeekChars(3): alp
ReadLine: alpha,beta
ReadFields: gamma|delta
Records in the file: 4

Option Strict On
Imports System.IO
Imports System.Text

Module Ex12
    Sub Main()
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim target As String = Path.Combine(root, "loans.dat")

            ' BinaryWriter/BinaryReader: primitives in little-endian order, strings prefixed with a 7-bit encoded length.
            Using writer As New BinaryWriter(File.Create(target), Encoding.UTF8)
                writer.Write(&H4C4F414E)        ' magic number
                writer.Write(CShort(1))         ' format version
                writer.Write("Dune")
                writer.Write(14.5D)             ' fine in Decimal
                writer.Write(New Date(2026, 1, 15).Ticks)
                writer.Write(True)
            End Using
            Dim bytes As Byte() = File.ReadAllBytes(target)
            Console.WriteLine($"{bytes.Length} bytes: {Convert.ToHexString(bytes)}")

            Using reader As New BinaryReader(File.OpenRead(target), Encoding.UTF8)
                Dim magic As Integer = reader.ReadInt32()
                Dim version As Short = reader.ReadInt16()
                Dim title As String = reader.ReadString()
                Dim fine As Decimal = reader.ReadDecimal()
                Dim ticks As Long = reader.ReadInt64()
                Dim flag As Boolean = reader.ReadBoolean()
                Console.WriteLine($"magic={magic:X}, version={version}, title={title}, fine={fine}, date={New Date(ticks):yyyy-MM-dd}, flag={flag}")
                Console.WriteLine($"At end: {reader.BaseStream.Position = reader.BaseStream.Length}")
                Try
                    reader.ReadInt32()
                Catch ex As EndOfStreamException
                    Console.WriteLine("Reading past the end: EndOfStreamException")
                End Try
            End Using

            ' Byte order is explicit with BitConverter and BinaryPrimitives.
            Dim number As Integer = &H01020304
            Console.WriteLine($"IsLittleEndian: {BitConverter.IsLittleEndian}")
            Console.WriteLine($"BitConverter:  {Convert.ToHexString(BitConverter.GetBytes(number))}")
            Dim big(3) As Byte
            System.Buffers.Binary.BinaryPrimitives.WriteInt32BigEndian(big, number)
            Console.WriteLine($"Big endian:    {Convert.ToHexString(big)}")

            ' Random access: patch one value in place.
            Using stream As New FileStream(target, FileMode.Open, FileAccess.ReadWrite)
                stream.Position = 4
                Dim versionBytes(1) As Byte
                stream.ReadExactly(versionBytes, 0, 2)
                Console.WriteLine($"Version before: {BitConverter.ToInt16(versionBytes, 0)}")
                stream.Position = 4
                stream.Write(BitConverter.GetBytes(CShort(2)), 0, 2)
            End Using
            Console.WriteLine($"Version after:  {BitConverter.ToInt16(File.ReadAllBytes(target), 4)}")

            Console.WriteLine($"Header magic as text: {Encoding.ASCII.GetString(File.ReadAllBytes(target), 0, 4)}")
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

36 bytes: 4E414F4C01000444756E65910000000000000000000000000001000080C006C953DE0801
magic=4C4F414E, version=1, title=Dune, fine=14.5, date=2026-01-15, flag=True
At end: True
Reading past the end: EndOfStreamException
IsLittleEndian: True
BitConverter:  04030201
Big endian:    01020304
Version before: 1
Version after:  2
Header magic as text: NAOL

Option Strict On
Imports System.IO
Imports System.IO.Compression
Imports System.Text

Module Ex14
    Sub Main()
        ' Streams compose: a StreamWriter over a GZipStream over a MemoryStream.
        Dim compressed As Byte()
        Dim text As String = String.Concat(Enumerable.Repeat("Dune;Frank Herbert;1965" & vbLf, 200))
        Using memory As New MemoryStream()
            Using gzip As New GZipStream(memory, CompressionLevel.Optimal, leaveOpen:=True)
                Using writer As New StreamWriter(gzip, New UTF8Encoding(False))
                    writer.Write(text)
                End Using
            End Using
            compressed = memory.ToArray()
        End Using
        Console.WriteLine($"Original {Encoding.UTF8.GetByteCount(text)} bytes, gzip {If(compressed.Length < 200, "under 200", "200 or more")} bytes")
        Using source As New MemoryStream(compressed)
            Using gzip As New GZipStream(source, CompressionMode.Decompress)
                Using reader As New StreamReader(gzip, Encoding.UTF8)
                    Console.WriteLine($"Decompressed equal: {reader.ReadToEnd() = text}")
                End Using
            End Using
        End Using

        ' StringReader and StringWriter give text APIs without files, which is what tests need.
        Using sw As New StringWriter()
            sw.WriteLine("line 1")
            sw.Write("line 2")
            Dim lines As String() = sw.ToString().Split(New String() {Environment.NewLine}, StringSplitOptions.None)
            Console.WriteLine($"StringWriter produced {lines.Length} lines")
        End Using

        ' CopyTo moves bytes between any two streams.
        Using input As New MemoryStream(Encoding.ASCII.GetBytes("copy me"))
            Using output As New MemoryStream()
                input.CopyTo(output)
                Console.WriteLine($"CopyTo copied {output.Length} bytes; input position {input.Position}")
            End Using
        End Using

        ' The safe update pattern: write a temporary file, then replace the target in one step.
        Dim root As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N"))
        Directory.CreateDirectory(root)
        Try
            Dim target As String = Path.Combine(root, "catalog.txt")
            File.WriteAllText(target, "version 1")
            Dim temp As String = target & ".tmp"
            File.WriteAllText(temp, "version 2")
            File.Move(temp, target, overwrite:=True)
            Console.WriteLine($"Atomic replace: {File.ReadAllText(target)}, temp left behind: {File.Exists(temp)}")

            ' Flush(True) asks the operating system to write to the device, not just to its cache.
            Using stream As New FileStream(target, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough)
                stream.Write(Encoding.ASCII.GetBytes("durable"))
                stream.Flush(flushToDisk:=True)
            End Using
            Console.WriteLine(File.ReadAllText(target))

            ' Never build a path from untrusted input without checking where it lands.
            Dim requested As String = "../../etc/passwd"
            Dim resolved As String = Path.GetFullPath(Path.Combine(root, requested))
            Dim inside As Boolean = resolved.StartsWith(Path.GetFullPath(root) & Path.DirectorySeparatorChar, StringComparison.Ordinal)
            Console.WriteLine($"Request '{requested}' stays inside the root: {inside}")

            ' Symbolic links and Unix permissions are visible too.
            If Not OperatingSystem.IsWindows() Then
                File.SetUnixFileMode(target, UnixFileMode.UserRead Or UnixFileMode.UserWrite)
                Console.WriteLine($"UnixFileMode: {File.GetUnixFileMode(target)}")
            End If
        Finally
            Directory.Delete(root, recursive:=True)
        End Try
    End Sub
End Module

Original 4800 bytes, gzip under 200 bytes
Decompressed equal: True
StringWriter produced 2 lines
CopyTo copied 7 bytes; input position 7
Atomic replace: version 2, temp left behind: False
durable
Request '../../etc/passwd' stays inside the root: False
UnixFileMode: UserWrite, UserRead

Option Strict On
Imports System.IO

Module Ex13
    ' Recognition only: the numbered-file model inherited from BASIC, still implemented by Microsoft.VisualBasic.
    Sub Main()
        Dim target As String = Path.Combine(Path.GetTempPath(), "shelf-" & Guid.NewGuid().ToString("N") & ".txt")
        Try
            Dim number As Integer = FreeFile()
            FileOpen(number, target, OpenMode.Output)
            PrintLine(number, "Dune", 1965)           ' Print # : plain text
            Write(number, "Emma", 1815, True)         ' Write # : comma-delimited, strings quoted, no line end
            Print(number, vbCrLf)
            WriteLine(number, "Ulysses", 1922, False) ' Write # plus the platform line end
            Console.WriteLine($"LOF while open: {LOF(number)} bytes, Loc={Loc(number)}")
            FileClose(number)
            Console.WriteLine(File.ReadAllText(target).Replace(vbCrLf, "<CRLF>" & vbLf))

            ' Input # reads typed fields written by Write #. It ends a record at CR or CRLF, not at a lone LF.
            Dim second As Integer = FreeFile()
            FileOpen(second, target, OpenMode.Input)
            Dim skip As String = LineInput(second)
            Dim title As String = Nothing
            Dim year As Integer
            Dim flag As Boolean
            Input(second, title)
            Input(second, year)
            Input(second, flag)
            Console.WriteLine($"Skipped [{skip.TrimEnd()}], then title={title}, year={year}, flag={flag}")
            Console.WriteLine($"EOF: {EOF(second)}")
            Try
                Input(second, title)
                Input(second, year)
                Input(second, flag)
            Catch ex As InvalidCastException
                Console.WriteLine("The record that ended with a lone LF did not terminate: InvalidCastException")
            End Try
            FileClose(second)

            ' Random access with Put and Get uses fixed-size records.
            Dim recordFile As String = target & ".dat"
            Dim third As Integer = FreeFile()
            FileOpen(third, recordFile, OpenMode.Random, OpenAccess.ReadWrite, OpenShare.Default, 4)
            FilePut(third, 100, 1)
            FilePut(third, 200, 2)
            FilePut(third, 300, 3)
            Dim value As Integer
            FileGet(third, value, 2)
            Console.WriteLine($"Record 2 = {value}, file length = {LOF(third)} bytes")
            FileClose(third)
            File.Delete(recordFile)

            ' Using a closed or unknown file number is a runtime error.
            Try
                Dim junk As String = LineInput(7)
            Catch ex As Exception
                Console.WriteLine($"Unopened file number: {ex.GetType().Name}")
            End Try
            ' Forgetting FileClose leaves the file locked for others.
            Dim fourth As Integer = FreeFile()
            FileOpen(fourth, target, OpenMode.Output, OpenAccess.Write, OpenShare.LockReadWrite)
            Try
                File.ReadAllText(target)
            Catch ex As IOException
                Console.WriteLine($"Open numbered file blocks other readers: {ex.GetType().Name}")
            End Try
            Reset() ' closes every file opened with FileOpen
        Finally
            File.Delete(target)
        End Try
    End Sub
End Module

LOF while open: 65 bytes, Loc=1
Dune           1965
"Emma",1815,#TRUE#,<CRLF>
"Ulysses",1922,#FALSE#

Skipped [Dune           1965], then title=Emma, year=1815, flag=True
EOF: False
The record that ended with a lone LF did not terminate: InvalidCastException
Record 2 = 200, file length = 12 bytes
Unopened file number: IOException
Open numbered file blocks other readers: IOException

Option Strict On

Module Ex19
    Sub Main()
        Dim text As String = File.ReadAllText("shelf.txt")
        Dim parser As New TextFieldParser("shelf.csv")
        Console.WriteLine(Path.Combine("a", "b") & text)
    End Sub
End Module

Ex19.vb(5,30): error BC30451: 'File' is not declared. It may be inaccessible due to its protection level.
Ex19.vb(6,27): error BC30002: Type 'TextFieldParser' is not defined.
Ex19.vb(7,27): error BC30451: 'Path' is not declared. It may be inaccessible due to its protection level.