.NET 4.5 file read performance sync vs async

by

There are lots of things wrong with the testing code. Most notably, your “async” test does not use async I/O; with file streams, you have to explicitly open them as asynchronous or else you’re just doing synchronous operations on a background thread. Also, your file sizes are very small and can be easily cached.

I modified the test code to write out much larger files, to have comparable sync vs async code, and to make the async code asynchronous:

static void Main(string[] args)
{
    Write("0.bin");
    Write("1.bin");
    Write("2.bin");

    ReadAllFile("2.bin"); // warmup

    var sw = new Stopwatch();
    sw.Start();
    ReadAllFile("0.bin");
    ReadAllFile("1.bin");
    ReadAllFile("2.bin");
    sw.Stop();

    Console.WriteLine("Sync: " + sw.Elapsed);

    ReadAllFileAsync("2.bin").Wait(); // warmup

    sw.Restart();
    ReadAllFileAsync("0.bin").Wait();
    ReadAllFileAsync("1.bin").Wait();
    ReadAllFileAsync("2.bin").Wait();
    sw.Stop();

    Console.WriteLine("Async: " + sw.Elapsed);

    Console.ReadKey();
}

static void ReadAllFile(string filename)
{
    using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false))
    {
        byte[] buff = new byte[file.Length];
        file.Read(buff, 0, (int)file.Length);
    }
}

static async Task ReadAllFileAsync(string filename)
{
    using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true))
    {
        byte[] buff = new byte[file.Length];
        await file.ReadAsync(buff, 0, (int)file.Length);
    }
}

static void Write(string filename)
{
    int size = 1024 * 1024 * 256;
    var data = new byte[size];
    var random = new Random();
    random.NextBytes(data);
    File.WriteAllBytes(filename, data);
}

On my machine, this test (built in Release, run outside the debugger) yields these numbers:

Sync: 00:00:00.4461936
Async: 00:00:00.4429566

More Related Contents:

  1. async/await – when to return a Task vs void?
  2. Run two async tasks in parallel and collect results in .NET 4.5
  3. awaitable Task based queue
  4. How does Task become an int?
  5. Is async HttpClient from .Net 4.5 a bad choice for intensive load applications?
  6. Using async / await with DataReader ? ( without middle buffers!)
  7. Open existing file, append a single line
  8. Notification when a file changes?
  9. Using .Net 4.5 Async Feature for Socket Programming
  10. Best way in .NET to manage queue of tasks on a separate (single) thread
  11. Enforce an async method to be called once
  12. Why can’t I use System.IO.File methods in an MVC controller?
  13. “async Task then await Task” vs “Task then return task” [duplicate]
  14. Asynchronous File Download with Progress Bar
  15. Wait for a void async method
  16. Create zip file from byte[]
  17. Do using statements and await keywords play nicely in c#
  18. C# Begin/EndReceive – how do I read large data?
  19. Extracting Windows File Properties (Custom Properties) C#
  20. Is .GetAwaiter().GetResult(); safe for general use?
  21. Async WebApi Thread.CurrentCulture
  22. How to split a large file into chunks in c#?
  23. Synchronous implementation of interface that returns Task
  24. How do I convert string to Indian Money format?
  25. Display tick labels in logarithmic scale MS Chart (log-log)
  26. Exclude certain file extensions when getting files from a directory
  27. How can I tell if a C# method is async/await via reflection?
  28. ConcurrentDictionary GetOrAdd async
  29. Large Object Heap Compaction, when is it good?
  30. Why does System.IO.File.Exists(string path) return false?

Leave a Comment