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?"