Wir versuchen, die Leistung zwischen dem Lesen einer Reihe von Dateien mithilfe von Synchronisationsmethoden und asynchron zu messen. Hatte erwartet, dass es ungefähr die gleiche Zeit zwischen den beiden gibt, stellt sich aber heraus, dass die Verwendung von Async ungefähr 5.5x langsamer ist.

Dies könnte an dem Aufwand liegen, der mit dem Verwalten der Threads verbunden ist, aber ich wollte nur Ihre Meinung wissen. Vielleicht messen wir nur das Timing falsch.

Dies sind die Methoden, die getestet werden:

    static void ReadAllFile(string filename)
    {
        var content = File.ReadAllBytes(filename);
    }

    static async Task ReadAllFileAsync(string filename)
    {
        using (var file = File.OpenRead(filename))
        {
            using (var ms = new MemoryStream())
            {
                byte[] buff = new byte[file.Length];
                await file.ReadAsync(buff, 0, (int)file.Length);
            }
        }
    }

Und dies ist die Methode, die sie ausführt und die Stoppuhr startet:

    static void Test(string name, Func<string, Task> gettask, int count)
    {
        Stopwatch sw = new Stopwatch();

        Task[] tasks = new Task[count];
        sw.Start();
        for (int i = 0; i < count; i++)
        {
            string filename = "file" + i + ".bin";
            tasks[i] = gettask(filename);
        }
        Task.WaitAll(tasks);
        sw.Stop();
        Console.WriteLine(name + " {0} ms", sw.ElapsedMilliseconds);

    }

Welches ist alles von hier ausgeführt:

    static void Main(string[] args)
    {
        int count = 10000;

        for (int i = 0; i < count; i++)
        {
            Write("file" + i + ".bin");
        }

        Console.WriteLine("Testing read...!");            

        Test("Read Contents", (filename) => Task.Run(() => ReadAllFile(filename)), count);
        Test("Read Contents Async", (filename) => ReadAllFileAsync(filename), count);

        Console.ReadKey();
    }

Und die Hilfsschreibmethode:

    static void Write(string filename)
    {
        Data obj = new Data()
        {
            Header = "random string size here"
        };
        int size = 1024 * 20; // 1024 * 256;

        obj.Body = new byte[size];

        for (var i = 0; i < size; i++)
        {
            obj.Body[i] = (byte)(i % 256);
        }

        Stopwatch sw = new Stopwatch();
        sw.Start();

        MemoryStream ms = new MemoryStream();
        Serializer.Serialize(ms, obj);
        ms.Position = 0;

        using (var file = File.Create(filename))
        {
            ms.CopyToAsync(file).Wait();
        }

        sw.Stop();
        //Console.WriteLine("Writing file {0}", sw.ElapsedMilliseconds); 
    }

Die Ergebnisse:

-Read Contents 574 ms
-Read Contents Async 3160 ms

Werde es wirklich zu schätzen wissen, wenn jemand etwas Licht ins Dunkel bringen kann, während wir den Stapel und das Web durchsucht haben, aber keine richtige Erklärung finden.