C# File Handling Exercises: 30 Coding Problems with Solutions

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "notes.txt";

        if (!File.Exists(filePath))
        {
            using (File.Create(filePath)) { }
            Console.WriteLine("File created: " + filePath);
        }
        else
        {
            Console.WriteLine("File already exists: " + filePath);
        }
    }
}Code language: C# (cs)

Explanation:

• File.Exists(filePath): Checks the file system for a file at the given path without opening or modifying it.
• if (!File.Exists(filePath)): Only proceeds with creation when the file is genuinely missing, preventing an existing file from being wiped out.
• using (File.Create(filePath)) { }: Creates the file and immediately closes the stream, since the empty block leaves the file with no content.
• Running it again: A second run finds the file already there and prints the “already exists” message instead of recreating it.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string name = "Alex";
        int age = 28;

        string content = "Name: " + name + ", Age: " + age;
        File.WriteAllText("user.txt", content);

        Console.WriteLine("Saved to user.txt");
    }
}Code language: C# (cs)

Explanation:

• string content = "Name: " + name + ", Age: " + age: Builds the full line of text before writing it, so the file receives one complete string.
• File.WriteAllText("user.txt", content): Creates user.txt if it doesn’t exist, or overwrites it completely if it does.
• Single method call: Handles opening the file, writing the text, and closing the file automatically, without needing a using block.
• Fixed sample values: name and age are hardcoded here so the example produces the same output every time; in an interactive console app these would typically come from Console.ReadLine() instead.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string content = File.ReadAllText("notes.txt");
        Console.WriteLine(content);
    }
}Code language: C# (cs)

Explanation:

• File.ReadAllText("notes.txt"): Opens the file, reads every character into memory, and closes the file automatically, returning the result as a single string.
• string content: Stores the file’s contents so it can be used or printed as many times as needed.
• Console.WriteLine(content): Prints the entire file to the console in one statement.
• Suitability: ReadAllText works well for small files, but very large files are usually better handled line-by-line to avoid loading everything into memory at once.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string logEntry = "Log entry at " + DateTime.Now + Environment.NewLine;
        File.AppendAllText("log.txt", logEntry);

        Console.WriteLine("Log entry appended");
    }
}Code language: C# (cs)

Explanation:

• DateTime.Now: Captures the current date and time, giving each log entry a unique timestamp.
• Environment.NewLine: Appended manually to the end of the entry, since AppendAllText writes exactly the string it’s given without adding a line break.
• File.AppendAllText("log.txt", logEntry): Adds the new entry after the file’s existing content instead of replacing it.
• Repeated runs: Each execution adds one more line to log.txt, building up a running history of entries over time.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "temp.txt";

        if (File.Exists(filePath))
        {
            File.Delete(filePath);
            Console.WriteLine("File deleted: " + filePath);
        }
        else
        {
            Console.WriteLine("File not found: " + filePath);
        }
    }
}Code language: C# (cs)

Explanation:

• File.Exists(filePath): Confirms the file is actually there before any deletion is attempted.
• File.Delete(filePath): Removes the file from disk, but only runs inside the branch where the existence check succeeded.
• Guarding the delete: Checking first keeps the intent of the code explicit and makes the two outcomes easy to branch on cleanly.
• Two distinct messages: The program reports a different outcome depending on whether the file was actually present, rather than assuming success.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("poem.txt");

        for (int i = 0; i < lines.Length; i++)
        {
            Console.WriteLine((i + 1) + ": " + lines[i]);
        }
    }
}Code language: C# (cs)

Explanation:

• File.ReadAllLines("poem.txt"): Reads the entire file and splits it into an array of strings, one element per line.
• for (int i = 0; i < lines.Length; i++): Loops through every line using its index, which is needed to build the line number.
• (i + 1): Converts the zero-based array index into a one-based line number that matches how lines are usually counted.
• lines[i]: Accesses the actual text of the current line to print alongside its number.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string sourcePath = "source/report.txt";
        string destinationPath = "backup/report.txt";

        File.Copy(sourcePath, destinationPath, true);
        Console.WriteLine("File copied to " + destinationPath);
    }
}Code language: C# (cs)

Explanation:

• File.Copy(sourcePath, destinationPath, true): Copies the file’s contents to the new location, with the third argument allowing it to overwrite an existing file at that destination.
• Passing true for overwrite: Without it, calling File.Copy on a destination that already exists throws an IOException.
• Directory assumption: File.Copy expects the destination folder to already exist; it does not create intermediate directories automatically.
• Confirmation message: Printed only after the copy operation completes without throwing an exception.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string sourcePath = "draft.txt";
        string destinationPath = "archive/draft_final.txt";

        File.Move(sourcePath, destinationPath);
        Console.WriteLine("File moved to " + destinationPath);
    }
}Code language: C# (cs)

Explanation:

• File.Move(sourcePath, destinationPath): Relocates the file from its original path to the new one, removing it from the source location entirely.
• Renaming as a special case: Giving a destination path in the same folder but with a different file name effectively renames the file.
• Destination folder requirement: The archive folder must already exist, since File.Move, like File.Copy, does not create missing directories.
• Existing destination file: If a file already exists at destinationPath, File.Move throws an exception instead of overwriting it.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("poem.txt");
        Console.WriteLine("Total lines: " + lines.Length);
    }
}Code language: C# (cs)

Explanation:

• File.ReadAllLines("poem.txt"): Reads the file and splits it into an array, with each element representing one line.
• lines.Length: Gives the exact count of lines without needing to loop through the array manually.
• Simplicity: This approach relies entirely on the array’s built-in property instead of writing a counting loop.
• Empty file behavior: An empty file still produces a valid array, just one with a length of zero rather than throwing an exception.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] items = { "Milk", "Eggs", "Bread" };

        File.WriteAllLines("shopping_list.txt", items);
        Console.WriteLine("Shopping list saved");
    }
}Code language: C# (cs)

Explanation:

• string[] items = { "Milk", "Eggs", "Bread" }: Defines the shopping list as an array, with each element representing one item.
• File.WriteAllLines("shopping_list.txt", items): Writes every element of the array to the file, automatically placing each one on its own line.
• Compared to WriteAllText: WriteAllLines is built specifically for arrays or collections of strings, so it removes the need to manually join elements with line break characters.
• Overwrite behavior: Like WriteAllText, this method replaces the file entirely if it already exists, rather than appending to it.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string wordToFind = "fox";
        string[] lines = File.ReadAllLines("story.txt");

        for (int i = 0; i < lines.Length; i++)
        {
            if (lines[i].Contains(wordToFind))
            {
                Console.WriteLine("Found on line " + (i + 1));
            }
        }
    }
}Code language: C# (cs)

Explanation:

• string wordToFind = "fox": Defines the target word once so the search stays consistent across the whole file.
• lines[i].Contains(wordToFind): Checks whether the current line includes the target word anywhere within it.
• for (int i = 0; i < lines.Length; i++): Iterates over every line while keeping track of its position in the array.
• (i + 1): Converts the zero-based index into a human-readable line number before printing it.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("employees.csv");

        foreach (string line in lines)
        {
            string[] parts = line.Split(',');
            string name = parts[0];
            string salary = parts[1];

            Console.WriteLine(name.PadRight(12) + salary);
        }
    }
}Code language: C# (cs)

Explanation:

• line.Split(','): Breaks each row into an array of two elements, since the file uses a comma as the delimiter between name and salary.
• parts[0] and parts[1]: Extract the name and salary values from the split array by their fixed position.
• name.PadRight(12): Pads the name with spaces up to a fixed width, so every salary lines up in the same column regardless of name length.
• foreach (string line in lines): Processes one row of the CSV at a time, keeping the parsing logic simple and readable.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string content = File.ReadAllText("sample.txt");

        int characterCount = content.Replace(" ", "").Length;
        int wordCount = content.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;

        Console.WriteLine("Characters (excluding spaces): " + characterCount);
        Console.WriteLine("Words: " + wordCount);
    }
}Code language: C# (cs)

Explanation:

• content.Replace(" ", ""): Removes every space from the text before measuring its length, so spaces don’t count toward the character total.
• content.Split(' ', StringSplitOptions.RemoveEmptyEntries): Splits the text into words on spaces, discarding any empty entries caused by extra whitespace.
• .Length on the resulting string and array: Gives the character count and word count respectively, without any manual counting loop.
• Single read: File.ReadAllText loads the file once, and both measurements are derived from that same string.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string directoryPath = "documents";
        string[] files = Directory.GetFiles(directoryPath);

        foreach (string filePath in files)
        {
            FileInfo info = new FileInfo(filePath);
            double sizeInKb = info.Length / 1024.0;

            Console.WriteLine(info.Name + " - " + sizeInKb + " KB");
        }
    }
}Code language: C# (cs)

Explanation:

• Directory.GetFiles(directoryPath): Returns the full path of every file directly inside the given folder, not including subfolders.
• new FileInfo(filePath): Wraps a single file path in an object that exposes metadata like size, name, and timestamps.
• info.Length / 1024.0: Converts the file’s size from bytes into kilobytes, using a double to preserve fractional values for small files.
• info.Name: Extracts just the file name from the full path, rather than printing the entire path each time.

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("app.log");
        string[] errorLines = lines.Where(line => line.Contains("Error")).ToArray();

        File.WriteAllLines("errors.log", errorLines);
        Console.WriteLine("Filtered lines saved to errors.log");
    }
}Code language: C# (cs)

Explanation:

• lines.Where(line => line.Contains("Error")): Filters the array down to only the lines that contain the word “Error”, using a LINQ query instead of a manual loop.
• .ToArray(): Converts the filtered LINQ result back into a string array, since File.WriteAllLines expects an array or collection of strings.
• File.WriteAllLines("errors.log", errorLines): Writes just the matching lines to a brand new file, leaving the original app.log untouched.
• Separation of concerns: Reading, filtering, and writing are each handled by a single, focused line of code.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        int age = 30;
        double price = 19.99;
        string name = "Widget";

        using (BinaryWriter writer = new BinaryWriter(File.Open("data.bin", FileMode.Create)))
        {
            writer.Write(age);
            writer.Write(price);
            writer.Write(name);
        }

        using (BinaryReader reader = new BinaryReader(File.Open("data.bin", FileMode.Open)))
        {
            int readAge = reader.ReadInt32();
            double readPrice = reader.ReadDouble();
            string readName = reader.ReadString();

            Console.WriteLine(readAge);
            Console.WriteLine(readPrice);
            Console.WriteLine(readName);
        }
    }
}Code language: C# (cs)

Explanation:

• BinaryWriter wrapped around File.Open("data.bin", FileMode.Create): Opens a file specifically for writing raw binary data rather than text.
• writer.Write(age), writer.Write(price), writer.Write(name): Writes each value in its native binary representation, one after another, in a fixed sequence.
• reader.ReadInt32(), reader.ReadDouble(), reader.ReadString(): Reads the values back in the exact same order they were written, since binary data has no built-in labels identifying each value.
• Order sensitivity: Reading the values in a different order, or with the wrong method, would produce garbage or throw an exception, since binary data relies entirely on a known, agreed-upon layout.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string content = File.ReadAllText("original.txt");
        string upperContent = content.ToUpper();

        File.WriteAllText("uppercase.txt", upperContent);
        Console.WriteLine("Converted file saved");
    }
}Code language: C# (cs)

Explanation:

• File.ReadAllText("original.txt"): Loads the source file’s content into a single string for processing.
• content.ToUpper(): Produces a new string with every character converted to uppercase, leaving the original string unchanged.
• File.WriteAllText("uppercase.txt", upperContent): Saves the transformed text to a separate file, rather than overwriting the original.
• Three-step pipeline: Read, transform, then write is a pattern that applies to many other text-processing tasks beyond just uppercase conversion.

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main()
    {
        string directoryPath = "documents";
        string[] files = Directory.GetFiles(directoryPath);

        FileInfo largest = files
            .Select(path => new FileInfo(path))
            .OrderByDescending(info => info.Length)
            .First();

        Console.WriteLine("Largest file: " + largest.Name + " (" + largest.Length + " bytes)");
    }
}Code language: C# (cs)

Explanation:

• files.Select(path => new FileInfo(path)): Converts each file path string into a FileInfo object so its size and other metadata become accessible.
• OrderByDescending(info => info.Length): Sorts the FileInfo objects from largest to smallest based on their byte size.
• .First(): Takes the top result from that sorted sequence, which is the single largest file in the folder.
• largest.Name and largest.Length: Read directly from the chosen FileInfo object to build the final output message.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "report.txt";
        FileInfo info = new FileInfo(filePath);

        Console.WriteLine("Created: " + info.CreationTime);
        Console.WriteLine("Last Accessed: " + info.LastAccessTime);
        Console.WriteLine("Attributes: " + info.Attributes);
    }
}Code language: C# (cs)

Explanation:

• new FileInfo(filePath): Creates an object representing the file’s metadata without reading its actual content.
• info.CreationTime and info.LastAccessTime: Expose the file’s timestamps directly as DateTime values, ready to print or format further.
• info.Attributes: Returns a FileAttributes value, which can combine multiple flags such as Hidden, ReadOnly, or Archive into a single result.
• No content is read: This entire program never opens the file’s contents, only the file system record describing it.

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("messy.txt");
        string[] cleanedLines = lines.Where(line => !string.IsNullOrWhiteSpace(line)).ToArray();

        File.WriteAllLines("messy.txt", cleanedLines);
        Console.WriteLine("Empty lines removed");
    }
}Code language: C# (cs)

Explanation:

• string.IsNullOrWhiteSpace(line): Returns true for lines that are empty, contain only spaces, or are entirely whitespace, catching more cases than a simple empty-string check.
• lines.Where(line => !string.IsNullOrWhiteSpace(line)): Keeps only the lines that fail that whitespace check, effectively filtering out the unwanted ones.
• File.WriteAllLines("messy.txt", cleanedLines): Writes the cleaned array back to the same file path, overwriting the original messy content.
• Same file overwrite: Since the destination path matches the source path, the original file itself ends up holding only the cleaned lines afterward.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "MyApp/Logs/Archive";

        if (!Directory.Exists(path))
        {
            Directory.CreateDirectory(path);
        }

        Console.WriteLine("Directory structure ready: " + path);
    }
}Code language: C# (cs)

Explanation:

• Directory.Exists(path): Checks whether the full nested folder structure already exists before attempting to create anything.
• Directory.CreateDirectory(path): Creates every missing folder along the path in one call, so MyApp, Logs, and Archive are all created together if none of them exist yet.
• No error on partial existence: If MyApp already exists but Logs and Archive don’t, CreateDirectory only creates the missing parts without throwing an exception.
• Idempotent behavior: Running the program again when the structure already exists does nothing harmful, since the initial check skips the creation step.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("original.txt");
        Array.Reverse(lines);

        File.WriteAllLines("reversed.txt", lines);
        Console.WriteLine("Reversed content saved to reversed.txt");
    }
}Code language: C# (cs)

Explanation:

• File.ReadAllLines("original.txt"): Loads every line of the source file into an array in its original order.
• Array.Reverse(lines): Reverses the array in place, so the last line becomes the first element and vice versa.
• File.WriteAllLines("reversed.txt", lines): Writes the now-reversed array to a separate file, one element per line.
• In-place modification: Array.Reverse changes the existing array directly rather than returning a new one, which is why the same lines variable is reused for writing.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string directoryPath = "documents";
        string extension = "*.pdf";

        string[] files = Directory.GetFiles(directoryPath, extension);

        foreach (string filePath in files)
        {
            Console.WriteLine(Path.GetFileName(filePath));
        }
    }
}Code language: C# (cs)

Explanation:

• Directory.GetFiles(directoryPath, extension): Filters the returned files directly at the file system level, so only files matching the pattern are included in the result.
• "*.pdf": The wildcard * matches any file name, while .pdf restricts the results to files with that specific extension.
• Path.GetFileName(filePath): Extracts just the file name from each full path, keeping the output clean and readable.
• Fixed sample values: directoryPath and extension are hardcoded here to keep the example deterministic; in an interactive console app they would typically come from Console.ReadLine().

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "missing.txt";

        try
        {
            string content = File.ReadAllText(filePath);
            Console.WriteLine(content);
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("File not found: " + filePath);
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("Access denied: " + filePath);
        }
        finally
        {
            Console.WriteLine("Read attempt finished");
        }
    }
}Code language: C# (cs)

Explanation:

• try { File.ReadAllText(filePath); }: Attempts the read operation, which may throw if the file is missing or inaccessible.
• catch (FileNotFoundException): Handles the specific case where the file simply doesn’t exist at the given path.
• catch (UnauthorizedAccessException): Handles a separate case where the file exists but the program lacks permission to read it.
• finally { ... }: Runs after either the try block succeeds or one of the catch blocks handles an exception, useful for cleanup or status messages that must always execute.

using System;
using System.IO;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        string[] fileA = File.ReadAllLines("fileA.txt");
        string[] fileB = File.ReadAllLines("fileB.txt");

        List<string> merged = new List<string>();
        int maxLength = Math.Max(fileA.Length, fileB.Length);

        for (int i = 0; i < maxLength; i++)
        {
            if (i < fileA.Length)
            {
                merged.Add(fileA[i]);
            }
            if (i < fileB.Length)
            {
                merged.Add(fileB[i]);
            }
        }

        File.WriteAllLines("merged.txt", merged);
        Console.WriteLine("Merged content saved to merged.txt");
    }
}Code language: C# (cs)

Explanation:

• int maxLength = Math.Max(fileA.Length, fileB.Length): Ensures the loop covers every line from whichever file is longer, so no content gets left out.
• if (i < fileA.Length) and if (i < fileB.Length): Guard each addition individually, so a shorter file simply contributes fewer lines without causing an index out of range error.
• merged.Add(...): Builds the interleaved sequence one line at a time, alternating between the two source files at each index.
• File.WriteAllLines("merged.txt", merged): Writes the final combined list to a new file, since List<string> works with the same overload File.WriteAllLines accepts for arrays.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Collections.Generic;

class Employee
{
    public string Name { get; set; }
}

class Company
{
    public string Name { get; set; }
    public List<Employee> Employees { get; set; }
}

class Program
{
    static byte[] key = Encoding.UTF8.GetBytes("0123456789ABCDEF0123456789ABCDEF");
    static byte[] iv = Encoding.UTF8.GetBytes("ABCDEF0123456789");

    static void SaveEncrypted(Company company, string filePath)
    {
        string json = JsonSerializer.Serialize(company);
        byte[] jsonBytes = Encoding.UTF8.GetBytes(json);

        using (Aes aes = Aes.Create())
        {
            aes.Key = key;
            aes.IV = iv;

            using (ICryptoTransform encryptor = aes.CreateEncryptor())
            using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
            using (CryptoStream cryptoStream = new CryptoStream(fileStream, encryptor, CryptoStreamMode.Write))
            {
                cryptoStream.Write(jsonBytes, 0, jsonBytes.Length);
            }
        }
    }

    static Company LoadDecrypted(string filePath)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = key;
            aes.IV = iv;

            using (ICryptoTransform decryptor = aes.CreateDecryptor())
            using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
            using (CryptoStream cryptoStream = new CryptoStream(fileStream, decryptor, CryptoStreamMode.Read))
            using (MemoryStream resultStream = new MemoryStream())
            {
                cryptoStream.CopyTo(resultStream);
                string json = Encoding.UTF8.GetString(resultStream.ToArray());
                return JsonSerializer.Deserialize<Company>(json);
            }
        }
    }

    static void Main()
    {
        Company company = new Company
        {
            Name = "Acme Corp",
            Employees = new List<Employee>
            {
                new Employee { Name = "Alice" },
                new Employee { Name = "Bob" }
            }
        };

        SaveEncrypted(company, "company.dat");

        Company loaded = LoadDecrypted("company.dat");
        Console.WriteLine("Company: " + loaded.Name + ", Employees: " + loaded.Employees.Count);
    }
}Code language: C# (cs)

Explanation:

• JsonSerializer.Serialize(company): Converts the entire object graph, including the nested list of employees, into a single JSON string.
• Aes.Create() with a fixed Key and IV: Sets up a symmetric encryption algorithm using the same key and initialization vector for both encrypting and decrypting, which must match exactly on both sides.
• CryptoStream wrapping a FileStream: Encrypts data as it’s written to disk, or decrypts it as it’s read back, without needing a separate buffer for the raw encrypted bytes.
• LoadDecrypted reversing the process: Decrypts the file’s bytes back into JSON text, then deserializes that text into a new Company object, restoring the original structure of data. In a real application, the key would come from a secure source rather than being hardcoded in the source file.

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

class Program
{
    static void Main()
    {
        string filePath = "huge_log.txt";
        byte[] pattern = Encoding.UTF8.GetBytes("ERROR");

        long occurrences = 0;

        using (MemoryMappedFile mappedFile = MemoryMappedFile.CreateFromFile(filePath, FileMode.Open))
        using (MemoryMappedViewStream viewStream = mappedFile.CreateViewStream())
        {
            int bufferSize = 65536;
            byte[] buffer = new byte[bufferSize];
            int bytesRead;

            while ((bytesRead = viewStream.Read(buffer, 0, bufferSize)) > 0)
            {
                for (int i = 0; i <= bytesRead - pattern.Length; i++)
                {
                    bool match = true;
                    for (int j = 0; j < pattern.Length; j++)
                    {
                        if (buffer[i + j] != pattern[j])
                        {
                            match = false;
                            break;
                        }
                    }

                    if (match)
                    {
                        occurrences++;
                    }
                }
            }
        }

        Console.WriteLine("Occurrences found: " + occurrences);
    }
}Code language: C# (cs)

Explanation:

• MemoryMappedFile.CreateFromFile(filePath, FileMode.Open): Maps the file’s contents into the process’s virtual address space, letting the operating system manage which parts are actually loaded into physical memory at any moment.
• mappedFile.CreateViewStream(): Provides a stream-like way to read through the mapped file sequentially, chunk by chunk, without needing to hold the entire file in a managed array.
• Nested byte comparison loop: Checks every possible starting position within each chunk for an exact match against the target pattern’s bytes.
• Running occurrences count: Accumulates across every chunk processed, so the final total reflects matches found throughout the entire file even though no single chunk ever contains all of it. A production version would also retain a small overlap of trailing bytes between chunks, since this simple approach can miss a pattern split across a chunk boundary.