Async file reading and writing in C Sharp (C#) - Time & Space Complexity

Time Complexity: Async file reading and writing

O(n)

Understanding Time Complexity

When working with async file reading and writing, it's important to understand how the time to complete these operations grows as the file size increases.

We want to know how the program's running time changes when reading or writing bigger files asynchronously.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

using System.IO;
using System.Threading.Tasks;

async Task CopyFileAsync(string source, string destination)
{
    using var reader = new StreamReader(source);
    using var writer = new StreamWriter(destination);
    string? line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        await writer.WriteLineAsync(line);
    }
}
    

This code reads a file line by line asynchronously and writes each line to another file asynchronously.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Reading and writing each line of the file asynchronously inside a loop.
• How many times: Once for every line in the file, so the number of lines determines the repetitions.

How Execution Grows With Input

As the file gets bigger with more lines, the program does more read and write operations, growing roughly in direct proportion to the number of lines.

Input Size (lines)	Approx. Operations
10	About 10 read and 10 write operations
100	About 100 read and 100 write operations
1000	About 1000 read and 1000 write operations

Pattern observation: The total operations grow linearly as the file size grows.

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the async reading and writing grows roughly in direct proportion to the number of lines in the file.

Common Mistake

[X] Wrong: "Async means the operation is instant and time does not grow with file size."

[OK] Correct: Async helps with responsiveness and not blocking, but the total work still depends on how much data is processed, so time grows with file size.

Interview Connect

Understanding how async file operations scale helps you explain performance in real apps and shows you grasp how asynchronous code works with data size.

Self-Check

"What if we read and wrote the entire file at once instead of line by line? How would the time complexity change?"

Practice

1.

What is the main benefit of using async file reading and writing in C#?

easy

A. It allows the program to continue running without waiting for the file operation to finish.

B. It makes the file operations run faster by using multiple threads automatically.

C. It locks the file so no other program can access it during reading or writing.

D. It compresses the file content before reading or writing.

Solution

1. Step 1: Understand async behavior in file operations

   Async methods let the program do other work while waiting for file I/O to complete.

2. Step 2: Identify the benefit of non-blocking operations

   This means the program does not freeze or wait, improving responsiveness.

3. Final Answer:

   It allows the program to continue running without waiting for the file operation to finish. -> Option A

4. Quick Check:

   Async = Non-blocking file I/O [OK]

Hint: Async means don't wait, keep running other code [OK]

Common Mistakes:

• Thinking async makes file operations faster
• Confusing async with file locking
• Assuming async compresses data

2.

Which of the following is the correct syntax to asynchronously read all text from a file named data.txt inside an async method?

?

easy

A. string content = File.ReadAllTextAsync("data.txt");

B. string content = await File.ReadAllTextAsync("data.txt");

C. await string content = File.ReadAllTextAsync("data.txt");

D. string content = await File.ReadAllText("data.txt");

Solution

1. Step 1: Recall async method syntax

   To get the result from an async method, you must use await before the call.

2. Step 2: Place await correctly with variable assignment

   The correct syntax is: string content = await File.ReadAllTextAsync("data.txt");

3. Final Answer:

   string content = await File.ReadAllTextAsync("data.txt"); -> Option B

4. Quick Check:

   Await async call to get string result [OK]

Hint: Use await before async call to get result [OK]

Common Mistakes:

• Forgetting await and getting a Task<string>
• Placing await after variable name
• Using synchronous ReadAllText with await

3.

What will be the output of the following code snippet?

async Task Example()
{
    await File.WriteAllTextAsync("test.txt", "Hello");
    string text = await File.ReadAllTextAsync("test.txt");
    Console.WriteLine(text);
}

// Assume Example() is called and awaited properly.

medium

A. test.txt

B. System.Threading.Tasks.Task

C. Hello

D. Compilation error

Solution

1. Step 1: Understand WriteAllTextAsync behavior

   The method writes "Hello" to the file "test.txt" asynchronously and waits for completion.

2. Step 2: Read the file content asynchronously

   Then it reads the content back from "test.txt" and stores it in text.

3. Step 3: Print the content

   Finally, it prints the string stored in text, which is "Hello".

4. Final Answer:

   Hello -> Option C

5. Quick Check:

   Write then read file content = Hello [OK]

Hint: Write then read async returns the written text [OK]

Common Mistakes:

• Expecting filename instead of content
• Confusing Task object with string result
• Missing await causing runtime errors

4.

Identify the error in this async file writing method:

async Task SaveData(string data)
{
    File.WriteAllTextAsync("output.txt", data);
    Console.WriteLine("Data saved.");
}

medium

A. Missing await before File.WriteAllTextAsync call.

B. The method should return void instead of Task.

C. The file path "output.txt" is invalid.

D. Console.WriteLine cannot be used inside async methods.

Solution

1. Step 1: Check async call usage

   The method calls File.WriteAllTextAsync but does not await it, so the write may not complete before printing.

2. Step 2: Understand await importance

   Without await, the method does not wait for the file write to finish, which can cause unexpected behavior.

3. Final Answer:

   Missing await before File.WriteAllTextAsync call. -> Option A

4. Quick Check:

   Await async calls to ensure completion [OK]

Hint: Always await async file operations to complete them [OK]

Common Mistakes:

• Forgetting await on async calls
• Changing return type unnecessarily
• Thinking Console.WriteLine is disallowed in async

5.

You want to read multiple text files asynchronously and combine their contents into one string. Which approach correctly uses async file reading to do this?

?

hard

A. Use await inside a loop to read each file one by one, appending results.

B. Read files using ReadAllTextAsync but ignore awaiting, just combine tasks directly.

C. Use synchronous ReadAllText inside an async method for simplicity.

D. Start all ReadAllTextAsync tasks without awaiting, then await them all together using Task.WhenAll and combine results.

Solution

1. Step 1: Understand async parallel reading

   Starting all read tasks without awaiting lets them run in parallel, improving speed.

2. Step 2: Use Task.WhenAll to await all tasks

   This waits for all reads to finish, then you can combine their string results safely.

3. Step 3: Avoid synchronous or missing await approaches

   Reading synchronously blocks the thread; ignoring await causes incomplete results.

4. Final Answer:

   Start all tasks, await with Task.WhenAll, then combine results. -> Option D

5. Quick Check:

   Parallel async reads + Task.WhenAll = efficient combination [OK]

Hint: Use Task.WhenAll to await multiple async reads together [OK]

Common Mistakes:

• Awaiting inside loop causing sequential reads
• Using synchronous reads in async method
• Not awaiting tasks causing incomplete data