How can I improve the performance of this CopyTo method?

Question

EDIT: I have now solved this. My answer posted below and will mark as solved when SO lets me.

I have a CopyTo (and a CopyToAsync) method to copy files in my C# application. I have found that it is actually quite slow to copy the files, compared to something like Xcopy.

I extracted the core functionality of the copy method and placed it into a test console app to get the speed that it operates at versus Xcopy, and found the results actually quite different.

The results I get are:

Async Method: 36.59 seconds - Average speed: 1512.63 mb/sec

Sync Method: 36.49 seconds - Average speed: 1516.72 mb/sec

XCOPY: 5.62 seconds - Average speed: 9842.11 mb/sec

All three of these used the exact same file, and the exact same destination.

StreamExtensions class:

public static class StreamExtensions
    {

        const int DEFAULT_BUFFER = 0x1000; // 4096 bits

        public static async Task CopyToAsync(this Stream source, Stream destination, IProgress<long> progress, CancellationToken cancellationToken = default, int bufferSize = DEFAULT_BUFFER)
        {
            var buffer = new byte[bufferSize];
            int bytesRead;
            long totalRead = 0;

            while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) > 0)
            {
                await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken);

                cancellationToken.ThrowIfCancellationRequested();

                totalRead += bytesRead;
                progress.Report(totalRead);
            }
        }

        public static void CopyTo(this Stream source, Stream destination, IProgress<long> progress, int bufferSize = DEFAULT_BUFFER)
        {
            var buffer = new byte[bufferSize];
            int bytesRead;
            long totalRead = 0;

            while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0)
            {
                destination.Write(buffer, 0, bytesRead);

                totalRead += bytesRead;
                progress.Report(totalRead);
            }
        }
    }

The IProgress<long> object is to report the file progress back to the calling method.

Example call implementation:

// Asynchronous version
public static async Task CopyFileSetAsync(Dictionary<string, string> fileSet)
{
    for (var x = 0; x < fileSet.Count; x++)
    {
        var item = fileSet.ElementAt(x);
        var from = item.Key;
        var to = item.Value;

        int currentProgress = 0;

        long fileSize = new FileInfo(from).Length;

        IProgress<long> progress = new SynchronousProgress<long>(value =>
        {
            decimal fileProg = (decimal)(value * 100) / fileSize;

            if (fileProg != currentProgress)
            {
                currentProgress = (int)fileProg;
                OnUpdateFileProgress(null, new FileProgressEventArgs(fileProg));
            }
        });

        using (var outStream = new FileStream(to, FileMode.Create, FileAccess.Write, FileShare.Read))
        {
            using (var inStream = new FileStream(from, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                await inStream.CopyToAsync(outStream, progress);
            }
        }

        OnUpdateFileProgress(null, new FileProgressEventArgs(100)); // Probably redundant
    }
}

// Synchronous version
public static void CopyFileSet(Dictionary<string, string> fileSet)
{
    for (var x = 0; x < fileSet.Count; x++)
    {
        var item = fileSet.ElementAt(x);
        var from = item.Key;
        var to = item.Value;

        int currentProgress = 0;

        long fileSize = new FileInfo(from).Length;

        IProgress<long> progress = new SynchronousProgress<long>(value =>
        {
            decimal fileProg = (decimal)(value * 100) / fileSize;

            if (fileProg != currentProgress)
            {
                currentProgress = (int)fileProg;
                OnUpdateFileProgress(null, new FileProgressEventArgs(fileProg));
            }
        });

        using (var outStream = new FileStream(to, FileMode.Create, FileAccess.Write, FileShare.Read))
        {
            using (var inStream = new FileStream(from, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                inStream.CopyTo(outStream, progress, 1024);
            }
        }

        OnUpdateFileProgress(null, new FileProgressEventArgs(100)); // Probably redundant
    }
}

Is there something that's preventing this from running as fast as it could? I'm just stumped as to how much slower it is compared to copy.

EDIT: Fixed a typo where I forgot a single ` around IProgress

Answer 1

Thanks to Tom and xanatos , I answered my own question:

I misunderstood the impact of buffer size. I had only gone so far as 8192 bytes as the buffer size. After taking on their suggestions, I increased the buffer size to 1mb (1048576 bytes), and this made a massive difference to the performance.

Async Method: 5.57 seconds - Average speed: 9938.68 mb/sec

Sync Method: 5.52 seconds - Average speed: 10028.36 mb/sec

XCOPY: 5.03 seconds - Average speed: 11007.84 mb/sec