C# Read and Write Text Files: Paths, Saved Lines, and Clear Failure Handling

What you will understand

• Distinguish a path, file contents and an in-memory string.
• Build fixed practice paths and create parent directories.
• Choose replacement or append based on the intended operation.
• Read whole text, arrays of lines or sequential lines deliberately.
• Use UTF-8 consistently and define one-line title records.
• Handle a missing file without disguising unrelated I/O failures.
• Dispose a writer before reading its completed output.
• Validate additions and verify reloaded data in a temporary practice folder.

A path, a file and a string are different things

A string variable lives in the running program. A text file stores encoded characters in a filesystem. A path is a string describing where to find that file; it is not the file contents. File.WriteAllText sends text to that location, while File.ReadAllText retrieves text into a new string value.

Our examples use a dedicated csharp-file-practice directory beneath the process working directory. The program creates that directory and uses fixed filenames so every write has an obvious scope. The first example writes River Maps, then reads the file back instead of merely printing the original variable.

On your own computer, a file written to an ordinary persistent folder can remain after the console program exits. On this website, each Run uses a fresh temporary container: files exist during that execution and are discarded afterward. Separate editors and separate runs do not share saved files. To keep files across runs, copy the complete example into a local console project and use its practice folder.

All filesystem work in the runnable examples stays inside that temporary environment. You are not editing your computer’s files through the browser runner. The expected-output reference shows what a correct program should print; only selecting Run performs the actual isolated write and read.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllText(path, "River Maps", Encoding.UTF8);
        string saved = File.ReadAllText(path, Encoding.UTF8);
        Console.WriteLine(saved);
    }
}

Select Run code to compile and execute this program.

River Maps

Build paths from known pieces and understand the working directory

Path.Combine builds a path using the platform’s separator rules. Combine a trusted folder with a fixed filename instead of manually mixing forward and backward slashes. A relative path is resolved against Directory.GetCurrentDirectory(), which is not necessarily the directory containing Program.cs.

Path.GetFullPath resolves a path string to an absolute location. It does not create anything or check that the file can be opened. Likewise Path.GetFileName extracts the final component from a string; it does not read a file. The path example prints stable facts rather than a machine-specific absolute path.

Directory.CreateDirectory creates the parent folder if necessary and is safe to call when it already exists. Writing a new file does not create a missing chain of parent folders automatically. The intentional caught-error example shows why directory setup belongs before the write.

Path.Combine is not a security boundary for arbitrary user input. A rooted component, traversal segments or filesystem links can redirect a path. These lessons use fixed trusted filenames. Real uploads or user-selected paths need their own authorization and containment design rather than assuming Combine makes them safe.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = "csharp-file-practice";
        string path = Path.Combine(folder, "notes.txt");
        Console.WriteLine(Path.GetFileName(path));
        Console.WriteLine(Path.IsPathRooted(path));
        Console.WriteLine(Path.IsPathRooted(Path.GetFullPath(path)));
    }
}

Select Run code to compile and execute this program.

notes.txt
False
True

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string path = Path.Combine(Directory.GetCurrentDirectory(), "not-created-parent", "list.txt");
        try
        {
            File.WriteAllText(path, "River Maps", Encoding.UTF8);
        }
        catch (DirectoryNotFoundException)
        {
            Console.WriteLine("Create the parent directory first");
        }
    }
}

Select Run code to compile and execute this program.

Create the parent directory first

Decide whether you mean replace or append before choosing a method

File.WriteAllText creates a new file or replaces the contents of an existing one. File.WriteAllLines does the same for a sequence of lines. Choose these when the supplied data is the complete desired snapshot, not merely the next entry.

File.AppendAllText and File.AppendAllLines add data at the end, creating the file when it does not exist if the parent directory is usable. Appending does not remove duplicates. Running the same append twice normally records the same entry twice unless your application adds a different rule.

AppendAllText writes the exact text you give it. It does not insert a newline between your records. The joined-title example demonstrates that a successful append can still produce an unusable format. Line helpers make one-record-per-line intent clearer for this reading list.

Even line appends need a valid existing record boundary. The lab starts with WriteAllLines, which writes line endings for its initial records. An arbitrary imported file that lacks a final newline needs an explicit policy before appending the next line. None of these helpers provides a multi-user transaction or an automatic backup of overwritten content.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllText(path, "River Maps", Encoding.UTF8);
        File.WriteAllText(path, "Night Trains", Encoding.UTF8);
        Console.WriteLine(File.ReadAllText(path, Encoding.UTF8));
    }
}

Select Run code to compile and execute this program.

Night Trains

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllText(path, "River Maps", Encoding.UTF8);
        File.AppendAllText(path, "Night Trains", Encoding.UTF8);
        Console.WriteLine(File.ReadAllText(path, Encoding.UTF8));
    }
}

Select Run code to compile and execute this program.

River MapsNight Trains

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "River Maps", "Night Trains" }, Encoding.UTF8);
        File.AppendAllLines(path, new[] { "Quiet Gardens" }, Encoding.UTF8);
        string[] titles = File.ReadAllLines(path, Encoding.UTF8);
        Console.WriteLine($"Count: {titles.Length}");
        for (int index = 0; index < titles.Length; index++)
        {
            Console.WriteLine($"{index + 1}. {titles[index]}");
        }
    }
}

Select Run code to compile and execute this program.

Count: 3
1. River Maps
2. Night Trains
3. Quiet Gardens

Choose whole text, all lines or sequential reading

File.ReadAllText returns one string containing all characters, including line separators. File.ReadAllLines returns an array of line strings without their terminators. Use the shape that matches the next step in your program rather than pretending those return types are interchangeable.

For a small reading list, a string array is easy to count, index and display. ReadAllLines loads the full list into memory, so the lab deliberately uses only a few bounded entries. The compiler-failure example assigns ReadAllText to string[] to make the difference visible.

File.ReadLines provides an enumerable that yields lines as you iterate, avoiding one up-front array of the entire file. Errors may arise during enumeration, not only when obtaining the enumerable. foreach manages its enumerator’s disposal when iteration completes or exits early.

An empty file is not the same as a file containing a blank line. The example writes both and compares their line counts. Do not invent an extra record just because a file ends with a newline, and decide deliberately whether blank lines are permitted in your format.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllText(path, "River Maps", Encoding.UTF8);
        string[] titles = File.ReadAllText(path, Encoding.UTF8);
    }
}

Select Run code to compile and execute this program.

Compilation fails: string cannot implicitly convert to string[].

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllText(path, "", Encoding.UTF8);
        Console.WriteLine($"Empty file lines: {File.ReadAllLines(path, Encoding.UTF8).Length}");
        File.WriteAllText(path, Environment.NewLine, Encoding.UTF8);
        Console.WriteLine($"Blank line count: {File.ReadAllLines(path, Encoding.UTF8).Length}");
    }
}

Select Run code to compile and execute this program.

Empty file lines: 0
Blank line count: 1

Text records need both an encoding and a record format

Encoding translates characters into bytes when writing and back into characters when reading. These examples specify Encoding.UTF8 at both sides. That keeps accented and Arabic title text readable without relying on a hidden platform-specific encoding choice.

Encoding is not encryption and does not protect confidential data. It also does not define how to separate records or escape special characters. Our line-based list permits one title per line, so an embedded carriage return or newline would split one logical title into more than one physical record.

The final helper therefore rejects titles containing either newline character and trims only outside whitespace. Spaces inside a valid title remain meaningful. This simple format cannot represent arbitrary multiline data; a structured format such as JSON may fit that requirement better, but is beyond this lesson.

Environment.NewLine supplies a platform-appropriate line separator when you construct text manually. You may encounter files created on other platforms, so validate the data format rather than comparing raw bytes to one operating system’s newline convention.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "Café Atlas", "رحلة صغيرة" }, Encoding.UTF8);
        foreach (string title in File.ReadAllLines(path, Encoding.UTF8))
        {
            Console.WriteLine(title);
        }
    }
}

Select Run code to compile and execute this program.

Café Atlas
رحلة صغيرة

Handle an expected missing file without hiding every failure

A first-time load may reasonably find no saved reading list. The missing-file example catches FileNotFoundException around the actual read and prints a clear first-use message. It first creates the parent directory so the example specifically concerns a missing file, not an absent directory.

File.Exists can be useful for display hints, but it is not a guarantee that the next read will succeed. Another process may change the file between a check and a read, and a false result can also conceal path or permission problems. Handle the operation that can fail rather than treating an existence check as a complete error policy.

Different failures mean different things: a missing parent directory, insufficient permission, a full disk or another I/O problem should not all become No saved list yet. Catch only what the current boundary can interpret meaningfully. The next lesson develops exception categories and recovery paths in more detail.

An append helper that returns false for invalid title text should not quietly swallow a write failure and claim that the text was invalid. The final lab returns true only after the write finishes; unexpected filesystem failures still propagate for an appropriate caller to handle.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        string missingPath = Path.Combine(folder, "not-created.txt");
        try
        {
            string text = File.ReadAllText(missingPath, Encoding.UTF8);
            Console.WriteLine(text);
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("No saved list yet");
        }
    }
}

Select Run code to compile and execute this program.

No saved list yet

Close writers so buffered content becomes available

The File read and write helpers shown earlier open and close their own file handles. You do not wrap their returned string or array in using. When you create a StreamWriter yourself, you own a resource that must be disposed.

A using block disposes StreamWriter when the block exits, including when an exception leaves the block. Disposal flushes buffered output and closes the writer. Reading after the block makes that boundary clear; merely constructing a writer and forgetting it can leave buffered data or an open handle.

The stream example uses append: false, so it replaces its dedicated practice file before writing two lines. After the writer closes, File.ReadLines iterates the result. This is a small preview of resource cleanup, not a reason to use streams for every tiny file operation.

Pick the simplest method that meets the size and workflow needs. Whole-file helpers are readable for small snapshots; streaming is useful for sequential processing when loading everything at once would be wasteful. Neither choice automatically makes writes atomic or coordinates simultaneous editors.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        using (StreamWriter writer = new StreamWriter(path, append: false, encoding: Encoding.UTF8))
        {
            writer.WriteLine("River Maps");
            writer.WriteLine("Night Trains");
        }
        foreach (string line in File.ReadLines(path, Encoding.UTF8))
        {
            Console.WriteLine(line);
        }
    }
}

Select Run code to compile and execute this program.

River Maps
Night Trains

Reload the file to prove what was saved

Printing a source array proves only that the array exists. The lab reads the file back and checks the reloaded count and titles. This catches choosing replacement where append was intended, losing line separators and forgetting to close a buffered writer.

Test a valid trimmed title, blank text, null and embedded line breaks. Invalid records must leave the stored list unchanged. Add the same title twice to understand the stated policy: duplicates are allowed here and each accepted append creates another record. Do not claim uniqueness without implementing it.

Each lab run deliberately writes a known two-title starting snapshot so the demonstration is repeatable inside the temporary runner. That reset is appropriate for a practice fixture, not an instruction to overwrite a real user’s saved list every time an application starts. A local application should separate one-time initialization from later loading and appending.

The repair and lab operate only on their own practice file. We do not delete unrelated files, export downloads or persist browser accounts. The next lesson will build clearer exception and cleanup policies on top of the I/O boundaries you have now traced.

Guided repair: append without losing the existing list

Adding Quiet Gardens leaves only that title in the file. The second operation replaces the entire snapshot. Preserve the original two titles and add the new line instead.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "River Maps", "Night Trains" }, Encoding.UTF8);
        File.WriteAllLines(path, new[] { "Quiet Gardens" }, Encoding.UTF8);
        Console.WriteLine(string.Join(" | ", File.ReadAllLines(path, Encoding.UTF8)));
    }
}

Select Run code to compile and execute this program.

Quiet Gardens

Repair checkpoints

1. Keep the first WriteAllLines as the known practice snapshot.
2. Replace the second WriteAllLines with AppendAllLines.
3. Read the file again rather than printing only the original array.
4. Verify all three titles remain in the intended order.
5. Recognize that another append would create a duplicate unless a separate uniqueness rule is added.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "River Maps", "Night Trains" }, Encoding.UTF8);
        File.AppendAllLines(path, new[] { "Quiet Gardens" }, Encoding.UTF8);
        Console.WriteLine(string.Join(" | ", File.ReadAllLines(path, Encoding.UTF8)));
    }
}

Select Run code to compile and execute this program.

River Maps | Night Trains | Quiet Gardens

Independent lab: save and reload a reading list

Complete a reading-list append helper that accepts one meaningful title per line. Reload the actual file after valid and invalid additions to prove what changed.

Acceptance checklist

• Create the dedicated practice directory and fixed reading-list path.
• Keep the initial two-line snapshot only as repeatable practice setup.
• Return false without a write for null, whitespace-only or multiline titles.
• Reject both carriage return and newline inside a supplied title.
• Trim outside whitespace and append exactly one line using UTF-8.
• Return true only after a successful append; do not swallow I/O failures as invalid text.
• Reload with ReadAllLines and print the saved count and each title.
• Explain that website runs are isolated and temporary, while a local project can keep its practice file.

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "River Maps", "Night Trains" }, Encoding.UTF8);
        Console.WriteLine($"Added: {TryAppendTitle(path, "  Quiet Gardens  ")}");
        Console.WriteLine($"Blank added: {TryAppendTitle(path, "   ")}");
        string[] saved = File.ReadAllLines(path, Encoding.UTF8);
        Console.WriteLine($"Saved titles: {saved.Length}");
        foreach (string title in saved)
        {
            Console.WriteLine(title);
        }
    }

    static bool TryAppendTitle(string path, string? title)
    {
        // TODO: reject blank or multiline titles; append one trimmed line otherwise.
        return false;
    }
}

Select Run code to compile and execute this program.

Added: False
Blank added: False
Saved titles: 2
River Maps
Night Trains

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string folder = Path.Combine(Directory.GetCurrentDirectory(), "csharp-file-practice");
        Directory.CreateDirectory(folder);
        string path = Path.Combine(folder, "reading-list.txt");
        File.WriteAllLines(path, new[] { "River Maps", "Night Trains" }, Encoding.UTF8);
        Console.WriteLine($"Added: {TryAppendTitle(path, "  Quiet Gardens  ")}");
        Console.WriteLine($"Blank added: {TryAppendTitle(path, "   ")}");
        string[] saved = File.ReadAllLines(path, Encoding.UTF8);
        Console.WriteLine($"Saved titles: {saved.Length}");
        foreach (string title in saved)
        {
            Console.WriteLine(title);
        }
    }

    static bool TryAppendTitle(string path, string? title)
    {
        if (string.IsNullOrWhiteSpace(title) || title.Contains('\n') || title.Contains('\r'))
        {
            return false;
        }
        File.AppendAllLines(path, new[] { title.Trim() }, Encoding.UTF8);
        return true;
    }
}

Select Run code to compile and execute this program.

Added: True
Blank added: False
Saved titles: 3
River Maps
Night Trains
Quiet Gardens

Changed-input checks

• A valid title with outside spaces adds one trimmed line.
• Null, blank, carriage-return and newline titles leave file contents unchanged.
• Non-Latin titles survive the UTF-8 round trip.
• Appending the same title twice creates two records under this stated policy.
• Appending to a missing file works when the parent directory already exists.
• A zero-entry starting snapshot can accept its first valid title.

Recap: choose the operation that matches your intent

Identify the path, the text format, whether the operation replaces or appends, and how the saved result will be verified.

Path.Combine

Build a path string from trusted components, not a containment guarantee.

Directory.CreateDirectory

Establish the parent directory before creating a file.

File.WriteAllText / WriteAllLines

Create or replace a complete text snapshot.

File.AppendAllText / AppendAllLines

Add supplied text or lines without automatic deduplication.

File.ReadAllText

Load the whole contents as one string.

File.ReadAllLines

Load a bounded list as strings without line terminators.

File.ReadLines

Enumerate lines sequentially with deferred reading.

using StreamWriter

Dispose an owned writer, flush buffered text and close the handle.

Frequently asked questions

Next step and references

File operations need deliberate paths, formats and write policies. Create the parent directory, distinguish replacement from append, close owned writers and reload data to verify what changed.

Next is C# Exceptions and Resource Cleanup. You will catch failures where recovery is meaningful and use using or finally to release resources predictably.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: Write text and dispose writers
• Microsoft Learn: File.ReadAllLines
• Microsoft Learn: File.WriteAllText replacement behavior

Last updated: 27 October 2026.